┌─────────────────────────────────────────────────────────────┐
│ USER IN ODOO (At Desk)                                      │
│                                                              │
│  SAM AI Chat: "Find my Q3 budget PDF"                       │
│      ↓                                                       │
│  Intent Processor (natural language → API calls)            │
│      ↓                                                       │
│  MVP Orchestrator Service                                   │
└──────────────────────────────────────────────────────────────┘
                         ↓
        ┌────────────────┼────────────────┬────────────────┐
        ↓                ↓                ↓                ↓
┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│ Google Drive │  │  OneDrive    │  │    Odoo      │  │    Slack     │
│   Client     │  │   Client     │  │ Attachments  │  │   Client     │
└──────────────┘  └──────────────┘  └──────────────┘  └──────────────┘
        │                │                │                │
        └────────────────┴────────────────┴────────────────┘
                         ↓
        Data Normalization Layer ("clearing layer")
                         ↓
        Unified Results (sorted by relevance/date)
                         ↓
        SAM AI Chat displays with source badges

api.service.provider (ai_brain)
  - OAuth tokens for AI providers (Claude, OpenAI, etc.)
  - access_token, refresh_token, expires_at
  - Token refresh logic
  - Subscription tracking
  - Budget caps

api_credentials (ai_brain)
  - N8N-style workflow credentials
  - Multiple credential types (OAuth2, API key, HTTP basic auth)
  - JSON credential data storage
  - Connection testing
  - Usage tracking
  - Supports: OpenAI, Google, Microsoft, Slack, Telegram, Notion, Discord, GitHub, etc.

api.operation.log (ai_brain)
  - API call logging
  - User identification
  - Service type tracking
  - Token usage and cost tracking
  - Error logging

/api/oauth/authorize
  - Initiates OAuth 2.0 flow
  - CSRF protection with state parameter
  - Redirects to provider (Google, Microsoft, etc.)

/api/oauth/callback
  - Receives OAuth callback
  - Exchanges code for tokens
  - Stores tokens in api.service.provider
  - Refreshes tokens when expired

/api/oauth/refresh_token
  - Manual token refresh endpoint

# Base client with OAuth refresh and rate limiting
ai_sam/services/integrations/base_client.py
  - BaseAPIClient class
  - OAuth token refresh logic
  - Rate limiting (respects API limits)
  - Error handling and retry logic
  - Logging to api.operation.log

# Service-specific clients
ai_sam/services/integrations/gdrive_client.py
  - GoogleDriveClient(BaseAPIClient)
  - search(query, file_type=None)
  - get_file(file_id)
  - download_file(file_id)
  - list_files(folder_id)

ai_sam/services/integrations/onedrive_client.py
  - OneDriveClient(BaseAPIClient)
  - search(query, file_type=None)
  - get_file(file_id)
  - download_file(file_id)

ai_sam/services/integrations/youtube_client.py
  - YouTubeClient(BaseAPIClient)
  - search_videos(query)
  - get_video(video_id)
  - get_transcript(video_id)

ai_sam/services/integrations/gmail_client.py
  - GmailClient(BaseAPIClient)
  - search_messages(query)
  - get_message(message_id)
  - send_message(to, subject, body)

ai_sam/services/integrations/slack_client.py
  - SlackClient(BaseAPIClient)
  - search_messages(query, channel)
  - post_message(channel, text)
  - get_channel_history(channel, limit)

class MVPOrchestrator(models.AbstractModel):
    _name = 'mvp.orchestrator'
    _description = 'Multi-source Orchestration Service'

    @api.model
    def search_files(self, query, sources=None, file_type=None):
        """
        Search for files across multiple sources

        Args:
            query: Search query string
            sources: List of sources ['gdrive', 'onedrive', 'odoo', 'slack']
                    If None, searches all connected sources
            file_type: Filter by file type (pdf, docx, xlsx, etc.)

        Returns:
            List of normalized results with metadata
        """
        results = []

        # Determine which sources to search
        active_sources = self._get_active_sources(sources)

        # Search each source in parallel
        for source in active_sources:
            client = self._get_client(source)
            source_results = client.search(query, file_type)
            results.extend(source_results)

        # Normalize results (clearing layer)
        normalized = self._normalize_results(results)

        # Log orchestration
        self.env['mvp.orchestration.log'].create({
            'user_id': self.env.user.id,
            'action': 'search',
            'request_data': {
                'query': query,
                'sources': sources,
                'file_type': file_type
            },
            'response_data': normalized,
            'result_count': len(normalized),
            'status': 'success'
        })

        return normalized

    def _get_client(self, source):
        """Get API client for source"""
        if source == 'gdrive':
            return self.env['google.drive.client']
        elif source == 'onedrive':
            return self.env['onedrive.client']
        elif source == 'odoo':
            return self.env['ai.context.builder']
        elif source == 'slack':
            return self.env['slack.client']

    def _normalize_results(self, results):
        """Normalize results to unified format"""
        normalized = []
        for result in results:
            normalized.append({
                'name': result.get('title') or result.get('name'),
                'source': result.get('source'),
                'url': result.get('url') or result.get('link'),
                'modified_date': result.get('modified') or result.get('updated_at'),
                'size': result.get('size'),
                'type': result.get('mime_type') or result.get('file_type'),
                'icon': self._get_source_icon(result.get('source')),
                'preview': result.get('snippet') or result.get('description')[:200],
            })

        # Sort by relevance/date
        normalized.sort(key=lambda x: x['modified_date'], reverse=True)

        return normalized

# ai_brain/models/mvp_orchestration_log.py
class MVPOrchestrationLog(models.Model):
    _name = 'mvp.orchestration.log'
    _description = 'Orchestration Execution Log'
    _order = 'created_date desc'

    user_id = fields.Many2one('res.users', required=True)
    action = fields.Selection([
        ('search', 'Search'),
        ('retrieve', 'Retrieve'),
        ('upload', 'Upload'),
    ])
    request_data = fields.Json()
    response_data = fields.Json()
    result_count = fields.Integer()
    execution_time = fields.Float()  # seconds
    status = fields.Selection([
        ('success', 'Success'),
        ('partial', 'Partial Success'),
        ('failed', 'Failed'),
    ])
    error_message = fields.Text()
    created_date = fields.Datetime(default=fields.Datetime.now)

class IntentProcessor(models.AbstractModel):
    _name = 'intent.processor'
    _description = 'Natural Language Intent Processor'

    @api.model
    def process(self, user_query):
        """
        Process natural language query into structured API call

        Args:
            user_query: "Find my Q3 budget PDF"

        Returns:
            {
                'action': 'search',
                'query': 'Q3 budget',
                'file_type': 'pdf',
                'sources': ['gdrive', 'onedrive', 'odoo'],
                'filters': {}
            }
        """
        # Extract intent
        intent = self._extract_intent(user_query)

        # Extract entities
        entities = self._extract_entities(user_query)

        # Build structured query
        return {
            'action': intent,
            'query': entities.get('search_term'),
            'file_type': entities.get('file_type'),
            'sources': entities.get('sources') or self._get_default_sources(),
            'filters': entities.get('filters', {})
        }

    def _extract_intent(self, query):
        """Determine user intent"""
        query_lower = query.lower()

        if any(word in query_lower for word in ['find', 'search', 'look for']):
            return 'search'
        elif any(word in query_lower for word in ['upload', 'save', 'store']):
            return 'upload'
        elif any(word in query_lower for word in ['download', 'get', 'retrieve']):
            return 'retrieve'
        else:
            return 'search'  # default

    def _extract_entities(self, query):
        """Extract entities from query"""
        entities = {}

        # File type detection
        if 'pdf' in query.lower():
            entities['file_type'] = 'pdf'
        elif 'docx' in query.lower() or 'document' in query.lower():
            entities['file_type'] = 'docx'
        elif 'xlsx' in query.lower() or 'spreadsheet' in query.lower():
            entities['file_type'] = 'xlsx'

        # Source detection
        if 'google drive' in query.lower():
            entities['sources'] = ['gdrive']
        elif 'onedrive' in query.lower():
            entities['sources'] = ['onedrive']
        elif 'slack' in query.lower():
            entities['sources'] = ['slack']

        # Extract search term (remove intent words and file types)
        search_term = query
        for word in ['find', 'search', 'pdf', 'docx', 'xlsx', 'in', 'my', 'the']:
            search_term = search_term.replace(word, '')
        entities['search_term'] = search_term.strip()

        return entities

# In chat controller, add orchestration detection
def process_message(self, message):
    # Check if message needs orchestration
    if self._needs_orchestration(message):
        # Use intent processor
        intent = self.env['intent.processor'].process(message)

        # Use orchestrator
        results = self.env['mvp.orchestrator'].search_files(
            query=intent['query'],
            sources=intent['sources'],
            file_type=intent['file_type']
        )

        # Format results for chat
        return self._format_orchestration_results(results)
    else:
        # Normal Claude AI response
        return self._get_claude_response(message)

def _needs_orchestration(self, message):
    """Detect if message needs API orchestration"""
    keywords = ['find', 'search', 'look for', 'show me', 'where is']
    return any(keyword in message.lower() for keyword in keywords)

def _format_orchestration_results(self, results):
    """Format orchestration results for chat display"""
    if not results:
        return "I couldn't find any files matching your query."

    response = f"I found {len(results)} files:\n\n"
    for result in results[:10]:  # Top 10
        source_badge = f"[{result['source'].upper()}]"
        response += f"{source_badge} {result['name']}\n"
        response += f"  Modified: {result['modified_date']}\n"
        response += f"  {result['preview']}\n\n"

    return response

# MCP server generator adds new tools:

async def get_recent_searches(self, arguments):
    """Get recent orchestration searches from Odoo"""
    logs = self.odoo.env['mvp.orchestration.log'].search([
        ('user_id', '=', self.current_user_id),
        ('action', '=', 'search'),
    ], limit=10, order='created_date desc')

    # Return cached results (no re-searching APIs)
    results = []
    for log in logs:
        results.append({
            'query': log.request_data['query'],
            'result_count': log.result_count,
            'when': log.created_date,
            'results': log.response_data  # Cached!
        })

    return TextContent(type="text", text=format_results(results))

async def execute_search(self, arguments):
    """Trigger orchestration search from mobile"""
    result = self.odoo.env['mvp.orchestrator'].search_files(
        query=arguments['query'],
        sources=arguments.get('sources'),
        file_type=arguments.get('file_type')
    )

    return TextContent(type="text", text=format_results(result))

# 5-minute TTL for search results
@lru_cache(maxsize=128)
def _cached_search(query, sources, ttl=300):
    # Return cached if exists and fresh
    pass

class BaseAPIClient:
    def __init__(self):
        self.rate_limiter = RateLimiter(
            requests_per_minute=60,  # Adjust per API
            burst_size=10
        )

# In base_client.py
def _log_api_call(self, service, operation, cost=0):
    self.env['api.operation.log'].create({
        'user_id': self.env.user.id,
        'service_type': service,
        'operation': operation,
        'cost': cost,  # If API charges per call
        'timestamp': fields.Datetime.now()
    })

# Check budget before API call
provider = self.env['api.service.provider'].search([
    ('service_type_name', '=', 'Google Drive'),
], limit=1)

if provider.monthly_cost >= provider.budget_cap:
    raise UserError('Monthly budget cap reached for Google Drive API')

class TestGoogleDriveClient(TransactionCase):
    def test_search(self):
        client = self.env['google.drive.client']
        results = client.search('budget', file_type='pdf')
        self.assertTrue(len(results) >= 0)

    def test_oauth_refresh(self):
        # Test token refresh when expired
        pass

class TestMVPOrchestrator(TransactionCase):
    def test_multi_source_search(self):
        orchestrator = self.env['mvp.orchestrator']
        results = orchestrator.search_files(
            query='Q3 budget',
            sources=['gdrive', 'odoo'],
            file_type='pdf'
        )
        # Verify results from both sources
        self.assertTrue(any(r['source'] == 'gdrive' for r in results))
        self.assertTrue(any(r['source'] == 'odoo' for r in results))

ai_brain/models/
  ✅ api_service_provider.py (OAuth infrastructure)
  ✅ api_credentials.py (credential storage)
  ✅ api_operation_log.py (API logging)
  ✅ ai_context_builder.py (Odoo data access)

ai_sam/controllers/
  ✅ api_oauth_controller.py (OAuth flow)
  ✅ vendor_registry_controller.py (vendor auto-population)

ai_sam/static/src/vendor_library/
  ✅ 100+ vendor config files

ai_brain/models/
  ❌ mvp_orchestration_log.py (orchestration logging)
  ❌ mvp_integration_connection.py (connection status)

ai_sam/services/integrations/
  ❌ base_client.py (base API client)
  ❌ gdrive_client.py (Google Drive)
  ❌ onedrive_client.py (OneDrive/Microsoft)
  ❌ youtube_client.py (YouTube)
  ❌ gmail_client.py (Gmail)
  ❌ slack_client.py (Slack)

ai_sam/services/
  ❌ mvp_orchestrator.py (orchestration service)
  ❌ intent_processor.py (natural language processing)

ai_sam/views/
  ❌ integration_connection_views.xml (UI for connections)
  ❌ orchestration_log_views.xml (UI for logs)

ai_sam/controllers/
  ❌ mvp_controller.py (orchestration API endpoints)