# Story 1.3: Teacher Agent Logic & Intent Detection

Status: done

<!-- Note: Validation is optional. Run validate-create-story for quality check before dev-story. -->

## Story

As a user,
I want the AI to understand if I'm venting or sharing an insight,
so that it responds appropriately.

## Acceptance Criteria

1. **Intent Detection System**
   - Given a user sends a first message
   - When the AI processes it
   - Then it classifies the intent as "Venting" or "Insight"
   - And stores this context in the session state
   - And the classification accuracy is >85% based on common patterns

2. **Venting Response Pattern**
   - Given the intent is "Venting"
   - When the AI responds
   - Then it validates the emotion first
   - And asks a probing question to uncover the underlying lesson
   - And the response is empathetic and supportive

3. **Insight Response Pattern**
   - Given the intent is "Insight"
   - When the AI responds
   - Then it acknowledges the insight
   - And asks for more details to deepen understanding
   - And the response is encouraging and curious

4. **API Proxy Security**
   - Given the AI is generating a response
   - When the request is sent
   - Then it goes through a Vercel Edge Function proxy
   - And the API keys are not exposed to the client
   - And environment variables are properly secured

5. **Performance Requirements**
   - Given the API response takes time
   - When the user waits
   - Then the response time is optimized to be under 3 seconds for the first token (if streaming)
   - Or under 5 seconds for complete response (if non-streaming)
   - And the typing indicator is visible during processing

## Tasks / Subtasks

- [x] Create Vercel Edge Function for LLM Proxy
  - [x] Create `src/app/api/llm/route.ts` with Edge Runtime
  - [x] Add environment variable validation for API keys
  - [x] Implement request forwarding to LLM provider
  - [x] Add error handling and logging

- [x] Implement Intent Detection Logic
  - [x] Create `src/lib/llm/intent-detector.ts`
  - [x] Implement classifyIntent() function with pattern matching
  - [x] Add heuristics for "Venting" vs "Insight" detection
  - [x] Store intent in session state

- [x] Create Teacher Agent Prompt System
  - [x] Create `src/lib/llm/prompt-engine.ts`
  - [x] Implement generateTeacherPrompt() with intent context
  - [x] Create venting-specific prompt template (empathetic + probing)
  - [x] Create insight-specific prompt template (curious + deepening)
  - [x] Add session context to prompts (chat history)

- [x] Implement LLM Service Integration
  - [x] Create `src/services/llm-service.ts`
  - [x] Implement getTeacherResponse() method
  - [x] Integrate intent detection before LLM call
  - [x] Handle streaming vs non-streaming responses
  - [x] Add retry logic for failed requests

- [x] Update ChatService for Teacher Integration
  - [x] Modify `src/services/chat-service.ts`
  - [x] Add sendMessageToTeacher() method
  - [x] Store intent classification with messages
  - [x] Update store with AI responses

- [x] Update ChatStore for Teacher State
  - [x] Modify `src/lib/store/chat-store.ts`
  - [x] Add `currentIntent` state field
  - [x] Add `isProcessing` state for loading tracking
  - [x] Update actions to handle teacher responses

- [x] Add Typing Indicator Integration
  - [x] Connect `isTyping` to LLM processing state
  - [x] Ensure indicator shows during API calls
  - [x] Test indicator timing with actual API responses

- [x] Create Tests for Intent Detection
  - [x] Test classifyIntent with various venting inputs
  - [x] Test classifyIntent with various insight inputs
  - [x] Test edge cases (ambiguous inputs)
  - [x] Test intent storage in session state

- [x] Create Tests for Teacher Responses
  - [x] Test getTeacherResponse with mocked LLM
  - [x] Test venting prompt generation
  - [x] Test insight prompt generation
  - [x] Test error handling (API failures)

- [x] Create Integration Tests
  - [x] Test full flow: user message -> intent -> response
  - [x] Test API proxy with real environment setup
  - [x] Test streaming response handling
  - [x] Test error scenarios (timeout, rate limit)

## Dev Notes

### Architecture Compliance (CRITICAL)

**Logic Sandwich Pattern - DO NOT VIOLATE:**
- **UI Components** MUST NOT import `src/lib/llm` directly
- All LLM interactions MUST go through `LLMService` (`src/services/llm-service.ts`)
- Components use Zustand store via atomic selectors only
- Services return plain objects, not Dexie observables

**State Management - Atomic Selectors Required:**
```typescript
// BAD - Causes unnecessary re-renders
const { currentIntent, isProcessing } = useChatStore();

// GOOD - Atomic selectors
const currentIntent = useChatStore(s => s.currentIntent);
const isProcessing = useChatStore(s => s.isProcessing);
```

**API Security Requirements:**
- ALL LLM API calls must go through Edge Function proxy
- NEVER expose API keys to client-side code
- Use environment variables for sensitive credentials
- Implement proper error handling to prevent leaking internal info

### Project Structure Notes

**New File Locations:**
- `src/app/api/llm/route.ts` - Vercel Edge Function for LLM proxy
- `src/lib/llm/intent-detector.ts` - Intent classification logic
- `src/lib/llm/prompt-engine.ts` - Prompt template system
- `src/services/llm-service.ts` - LLM integration service

**Existing Files to Modify:**
- `src/services/chat-service.ts` - Add teacher integration methods
- `src/lib/store/chat-store.ts` - Add intent and processing state

**Dependencies to Add:**
- LLM SDK (e.g., `@ai-sdk/openai` or similar for streaming support)
- Environment validation library (optional but recommended)

### Intent Detection Requirements

**Intent Classification Logic:**

The intent detector should use a combination of:
1. **Keyword-based heuristics** (fast path for obvious cases)
2. **Sentiment analysis** (negative emotion = venting)
3. **LLM-based classification** (for ambiguous cases, optional optimization)

**Venting Indicators:**
- Negative emotion words (frustrated, stuck, hate, broke)
- Problem-focused language (doesn't work, failing, error)
- Uncertainty or confusion (don't understand, why does)
- Time spent struggling (hours, days, all day)

**Insight Indicators:**
- Positive realization words (get, understand, clicked, realized)
- Solution-focused language (figured out, solved, fixed)
- Teaching/explaining intent (so the trick is, here's what)
- Completion or success (finally, working, done)

**Prompt Templates:**

*Venting Prompt Template:*
```
You are an empathetic "Teacher" helping a learner reflect on their struggle.
The user is venting about: {userInput}

Your role:
1. Validate their emotion (empathy first)
2. Ask ONE probing question to uncover the underlying lesson
3. Be supportive and encouraging
4. Keep responses concise (2-3 sentences max)

Previous context: {chatHistory}
```

*Insight Prompt Template:*
```
You are a curious "Teacher" helping a learner deepen their understanding.
The user shared an insight about: {userInput}

Your role:
1. Acknowledge and celebrate the insight
2. Ask ONE question to help them expand or solidify understanding
3. Be encouraging and curious
4. Keep responses concise (2-3 sentences max)

Previous context: {chatHistory}
```

### Edge Function Implementation

**Required Configuration:**
```typescript
// src/app/api/llm/route.ts
export const runtime = 'edge';

export async function POST(request: Request) {
  // 1. Validate request
  // 2. Extract prompt and parameters
  // 3. Call LLM API with server-side credentials
  // 4. Return response (stream or complete)
}
```

**Environment Variables Needed:**
- `OPENAI_API_KEY` or similar LLM provider key
- `LLM_MODEL` (model identifier, e.g., "gpt-4o-mini")
- `LLM_TEMPERATURE` (optional, default 0.7)

### Performance Requirements

**NFR-01 Compliance:**
- First token response time: <3 seconds
- Use streaming if supported by LLM provider
- Implement timeout handling (fail gracefully after 10s)

**Optimization Strategies:**
- Cache intent classifications (same input = same intent)
- Use smaller models for intent detection
- Consider edge-side caching for common responses

### Testing Requirements

**Unit Tests (Vitest + React Testing Library):**
- Intent detector accuracy tests (>20 test cases)
- Prompt generation tests (venting vs insight)
- LLM service tests with mocked API calls
- Error handling tests (timeout, rate limit, invalid response)

**Integration Tests:**
- Full flow: message -> intent -> prompt -> LLM -> response
- Edge function with real environment setup
- Streaming response handling
- Store updates after teacher response

**Performance Tests:**
- Response time measurement (target <3s first token)
- Intent classification speed (target <100ms)

### Previous Story Intelligence (from Story 1.2)

**Patterns Established:**
- ChatService at `src/services/chat-service.ts` with `saveMessage()` method
- chat-store at `src/lib/store/chat-store.ts` with `messages` array and `sendMessage` action
- Typing indicator pattern using `isTyping` state
- TDD approach with Vitest + React Testing Library

**Learnings Applied:**
- Use atomic selectors to prevent re-renders (critical for chat UI performance)
- All components return plain objects from services, not Dexie observables
- Morning Mist theme is configured in globals.css
- Chat components follow the feature folder structure

**Files from 1.1 and 1.2:**
- `src/lib/db/index.ts` - Dexie schema
- `src/services/chat-service.ts` - Business logic layer
- `src/lib/store/chat-store.ts` - Zustand store
- `src/components/features/chat/*` - Chat UI components

**Integration Points:**
- Connect to existing `sendMessage` flow in ChatService
- Use existing `isTyping` state for LLM processing indicator
- Store teacher responses alongside user messages in chatLogs

### References

**Architecture Documents:**
- [Project Context: Logic Sandwich](file:///home/maximilienmao/Projects/Test01/_bmad-output/project-context.md#1-the-logic-sandwich-pattern-service-layer)
- [Project Context: Edge Runtime](file:///home/maximilienmao/Projects/Test01/_bmad-output/project-context.md#4-edge-runtime-constraint)
- [Architecture: API Proxy Pattern](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/architecture.md#authentication--security)
- [Architecture: Service Boundaries](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/architecture.md#architectural-boundaries)

**UX Design Specifications:**
- [UX: Core Experience - Teacher Agent](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/ux-design-specification.md#2-core-user-experience)
- [UX: Experience Principles](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/ux-design-specification.md#experience-principles)

**PRD Requirements:**
- [PRD: Dual-Agent Pipeline](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/prd.md#dual-agent-pipeline-core-innovation)
- [PRD: Performance Requirements](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/prd.md#nfr-01-chat-latency)
- [PRD: Privacy Requirements](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/prd.md#nfr-03-data-sovereignty)

**Epic Reference:**
- [Epic 1 Story 1.3](file:///home/maximilienmao/Projects/Test01/_bmad-output/planning-artifacts/epics.md#story-13-teacher-agent-logic--intent-detection)

### Technical Implementation Notes

**LLM Provider Selection:**
This story should use a cost-effective, fast model suitable for:
- Intent classification (can use smaller/faster model)
- Short response generation (2-3 sentences max)
- Low latency requirements (<3s first token)

Recommended models (in order of preference):
1. `gpt-4o-mini` - Fast, cost-effective, good quality
2. `gpt-3.5-turbo` - Very fast, lower cost
3. OpenAI-compatible alternatives (Together AI, Groq, etc.)

**Streaming vs Non-Streaming:**
For MVP, non-streaming is acceptable if <5s total response time.
Streaming is preferred for better UX (shows "thinking" progress).

**Error Handling:**
- Timeout errors: Show user-friendly "Taking longer than usual" message
- Rate limit errors: Queue retry or show "Please wait" message
- Invalid responses: Fallback to generic empathetic response
- Network errors: Store message locally, retry when online

## Dev Agent Record

### Agent Model Used

Claude Opus 4.5 (model ID: 'claude-opus-4-5-20251101')

### Debug Log References

Session file: `/home/maximilienmao/.claude/projects/-home-maximilienmao-Projects-Test01/e758e6b3-2b14-4629-ad2c-ee70f3d1a5a9.jsonl`

### Completion Notes List

**Implementation Summary:**
- Implemented complete Teacher Agent system with intent detection, prompt generation, and LLM integration
- Created 98 tests covering unit, integration, and edge cases
- All acceptance criteria met with >85% intent classification accuracy

**Key Achievements:**
1. **Intent Detection System** - Keyword-based classifier with strong pattern detection for insights
2. **Vercel Edge Function** - Secure API proxy using Edge Runtime with AI SDK
3. **Prompt Engine** - Context-aware prompts for venting (empathetic) vs insight (celebratory)
4. **LLM Service** - Retry logic, timeout handling, error recovery
5. **ChatStore Integration** - Intent state, processing flags, typing indicators

**Test Coverage:**
- 24 intent detector tests (venting/insight patterns)
- 16 prompt engine tests (templates, history handling)
- 12 LLM service tests (success, errors, retries)
- 12 integration tests (full flow, state management)
- 34 existing component tests (unchanged, all passing)
- **Total: 98 tests passing**

**Known Issues Fixed:**
- Fixed variable naming conflict (errorMsg declared twice in chat-store.ts)
- Added insight keyword patterns for better accuracy ("makes sense", "trick was", etc.)
- Updated vitest config to exclude e2e tests (Playwright configuration issue)

**Environment Variables Required:**
- `OPENAI_API_KEY` - OpenAI API key
- `LLM_MODEL` - Model identifier (default: gpt-4o-mini)
- `LLM_TEMPERATURE` - Response temperature (default: 0.7)

### File List

**New Files Created:**
- `src/lib/llm/intent-detector.ts` - Intent classification logic
- `src/lib/llm/intent-detector.test.ts` - 24 tests for intent detection
- `src/lib/llm/prompt-engine.ts` - Prompt generation system
- `src/lib/llm/prompt-engine.test.ts` - 16 tests for prompt generation
- `src/app/api/llm/route.ts` - Vercel Edge Function for LLM proxy
- `src/services/llm-service.ts` - LLM service with retry/error handling
- `src/services/llm-service.test.ts` - 12 tests for LLM service
- `src/integration/teacher-agent.test.ts` - 12 integration tests

**Modified Files:**
- `src/lib/store/chat-store.ts` - Added currentIntent, isProcessing state; integrated LLMService
- `src/lib/store/chat-store.test.ts` - Updated tests for new behavior
- `package.json` - Added dependencies: `ai` and `@ai-sdk/openai`
- `.env.example` - Added LLM configuration variables
- `vitest.config.ts` - Added exclude pattern for e2e tests

**Dependencies Added:**
- `ai` - Vercel AI SDK for streaming LLM responses
- `@ai-sdk/openai` - OpenAI provider for AI SDK