// From sam_chat_client.js
const contextToSend = { ...this.context };
if (!contextToSend.url && typeof window !== 'undefined') {
    contextToSend.url = window.location.href;
}
formData.append('message', userMessage);
formData.append('conversation_id', conversationId);
formData.append('context_data', JSON.stringify(contextToSend));

const response = await fetch('/sam_ai/chat/send_streaming', {
    method: 'POST',
    credentials: 'include',
    body: formData,
    headers: { 'X-Requested-With': 'XMLHttpRequest' }
});

@http.route('/sam_ai/chat/send_streaming', type='http', auth='user', methods=['POST'], csrf=False)
def send_message_streaming(self, **kwargs):
    message = kwargs.get('message', '')
    conversation_id = kwargs.get('conversation_id')
    context_data_str = kwargs.get('context_data', '{}')
    context_data = json.loads(context_data_str)

def gather_context(self, context_data, user_message=None):
    context = {
        'raw_data': context_data,
        'files': [],
        'folder_content': None,
        'node': None,
        'workflow': None,
        'user_prefs': {},
        'mode': 'default',
        'memories': [],
    }

event: activity
data: {"type": "activity", "activity": "searching_memory", "message": "Searching memories..."}

session = SessionManager.get_or_create_session(env, user_id, context_data)

def get_location_insights(env, context_data):
    domain_key, domain_config = _detect_domain(context_data)
    return {
        'domain': domain_key,
        'domain_name': domain_config['name'],
        'primary_model': domain_config['primary_model'],
        'related_models': domain_config['related_models'],
        'tools': domain_config['tools'],
        'knowledge': domain_config['knowledge'],
    }

identity = {
    'name': 'SAM',
    'personality': self._load_personality_file(),  # From config file
    'permissions': self._get_sam_permissions(),
    'user_id': self.sam_user.id
}

business = {
    'company_name': company.name,
    'company_id': company.id,
    'business_description': company.sam_business_context,  # User-configured
    'currency': company.currency_id.name
}

tools = list(CORE_TOOLS)      # CRUD tools from core_tools.py
tools.extend(CHAT_TOOLS)       # Memory tools from chat_tools.py
tools.extend(location_tools)   # Location-specific tools

# CURRENT LOCATION
**URL:** `/web#action=123&model=crm.lead&id=45`
**Area:** CRM
**Odoo Model:** `crm.lead`
**Record ID:** 45

# Who You Are
You are **SAM** (Smart Assistant Manager), an AI assistant integrated into Odoo.
[personality content]

# Business Context
You work for **Acme Corp**.
[business description]

# CRM Knowledge
[Domain-specific context about CRM]

# User Context
You are currently assisting **John Smith**.

# Your Capabilities
You have tools to interact with this Odoo system.

**CRITICAL INSTRUCTION:** When the user asks about data, records, counts,
or information in Odoo, you MUST use your tools to query the database.

Available tools (use them!):
- `odoo_search`: Search for records...
- `odoo_read`: Read specific record details...
- `odoo_create`: Create new records...
- `odoo_write`: Update existing records...
- `memory_recall`: Search past conversations...

{
    'system_prompt': system_prompt,      # 3000-5000+ tokens
    'tools': tools,                      # 10-20 tools
    'session_id': session_id,
    'location': location,
    'user': user_info,
    'expires_on_location_change': True,
    'context_data': context_data,
}

class SAMChat:
    def __init__(self, env, session_context):
        self.env = env
        self.session = session_context
        self.system_prompt = session_context.get('system_prompt')  # Pre-built!
        self.tools = session_context.get('tools')                  # Pre-built!
        self.messages = session_context.get('conversation_history', [])

    def process_message_streaming(self, user_message, conversation_id=None):
        # Add user message to history
        self.messages.append({
            'role': 'user',
            'content': user_message
        })

        # Call AI API with pre-built context
        for chunk in self._call_ai_api_streaming():
            yield chunk

{
    'system_prompt': '[3000-5000 tokens of assembled context]',
    'messages': [
        {'role': 'user', 'content': 'previous message 1'},
        {'role': 'assistant', 'content': 'previous response 1'},
        {'role': 'user', 'content': 'current user message'},
    ],
    'tools': [
        {
            'name': 'odoo_search',
            'description': 'Search Odoo records...',
            'input_schema': {...}
        },
        # ... 10-20 more tools
    ],
    'model': 'claude-opus-4-5-20251101',  # or gpt-4o, etc.
}

# api_services.py:161-168
def send(self, messages, config, system_prompt=None, tools=None):
    api_format = self._get_api_format(config)  # 'anthropic' or 'openai'

    if api_format == 'anthropic':
        return self._call_anthropic_api(...)
    elif api_format == 'openai':
        return self._call_openai_api(...)

def _execute_single_tool(self, tool_call):
    tool_name = tool_call.get('name')
    params = tool_call.get('input', {})

    if tool_name in get_core_tool_names():
        result = execute_core_tool(self.env, self.sam_user, tool_name, params)
    elif tool_name in get_chat_tool_names():
        result = execute_chat_tool(self.env, tool_name, params)

    return {'tool_call_id': id, 'result': result, 'success': True}

# core_tools.py:624-643
def _execute_search(Model, params):
    domain = params.get('domain', [])
    fields = params.get('fields', [])
    limit = min(params.get('limit', 50), 500)

    records = Model.search(domain, limit=limit)
    return {'records': records.read(fields), 'count': len(records)}

# Status
yield f"event: status\ndata: {json.dumps({'status': 'Thinking...', 'progress': 50})}\n\n"

# Activity
yield f"event: activity\ndata: {json.dumps({'activity': 'executing_tool', 'tool': 'odoo_search'})}\n\n"

# Text chunks
yield f"event: chunk\ndata: {json.dumps({'text': 'Hello, how can I'})}\n\n"

# Tool results
yield f"event: tool_result\ndata: {json.dumps({'tool': 'odoo_search', 'success': True})}\n\n"

# Done
yield f"event: done\ndata: {json.dumps({'conversation_id': 123})}\n\n"

_processEvent(eventType, data) {
    switch (eventType) {
        case 'activity':
            this.onActivity(data.activity, data.params);  // Update activity indicator
            break;
        case 'chunk':
            this.onToken(data.text);  // Append text to message bubble
            fullResponse += data.text;
            break;
        case 'tool_result':
            // Tool executed successfully
            break;
        case 'done':
            this.onDone(result);  // Finalize message
            break;
    }
}