feat: file upload + expense report creation from Discuss attachments

- Discuss bot now reads ir.attachment from incoming messages; file-only
  messages no longer silently dropped
- ZIP files are described (contents listed) and bot asks clarifying
  question before acting; user's follow-up reply looks back for pending
  attachments so files don't need to be re-uploaded
- receipt_parser: extracts text from ZIP (recursive), JPG/PNG/etc (OCR),
  PDF (pdfplumber), HTML, TXT
- expenses_agent: full rewrite fixing broken method signatures; adds
  create_expense_sheet / create_expense / attach_receipt flow driven by
  LLM receipt parsing (Ollama, HIPAA-locked)
- master_agent: extra_context threads receipts + user_id into directives
- FastAPI /upload multipart endpoint; registered in main.py
- Odoo /ai/upload controller proxies files to agent service
- ab_ai_bot: dispatch_message_with_files() for multipart uploads

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

agent_service/agents/base_agent.py

@@ -27,6 +27,7 @@ class DirectiveContext:
     recent_findings: list = field(default_factory=list)
     conversation_summary: str = ''
     peer_data: dict = field(default_factory=dict)
+    receipts: list = field(default_factory=list)   # populated by upload flow
 
 
 @dataclass

agent_service/agents/expenses_agent.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
+import json
 import logging
+from datetime import date as _date
 from .base_agent import BaseAgent, AgentReport, AgentDirective, SweepReport
 from ..tools.expenses_tools import ExpensesTools
 
@@ -46,23 +48,27 @@ class ExpensesAgent(BaseAgent):
     def __init__(self, odoo, llm, peer_bus=None):
         super().__init__(odoo, llm, peer_bus)
         self._et = ExpensesTools(odoo)
-        self._gathered_data = {}
-        self._actions_taken = []
-        self._escalations_list = []
+        self._gathered_data: dict = {}
+        self._actions_taken: list = []
+        self._escalations_list: list = []
 
-    async def _plan(self, directive: AgentDirective) -> dict:
-        intent = (directive.intent or '').lower()
+    async def _plan(self) -> dict:
+        task = (self._directive.task if self._directive else '').lower()
+        receipts = getattr(self._directive.context, 'receipts', []) if self._directive else []
         return {
-            'fetch_summary': any(k in intent for k in ('summary', 'overview', 'report')),
-            'fetch_pending': any(k in intent for k in ('pending', 'approve', 'approval')),
-            'employee_id': directive.context.get('employee_id'),
-            'date_from': directive.context.get('date_from'),
-            'date_to': directive.context.get('date_to'),
+            'mode': 'create_from_receipts' if receipts else 'read',
+            'fetch_summary': any(k in task for k in ('summary', 'overview')) and not receipts,
+            'fetch_pending': any(k in task for k in ('pending', 'approve', 'approval')) and not receipts,
+            'employee_id': self._directive.params.get('employee_id') if self._directive else None,
+            'date_from': self._directive.params.get('date_from') if self._directive else None,
+            'date_to': self._directive.params.get('date_to') if self._directive else None,
         }
 
-    async def _gather(self, ctx: dict) -> dict:
-        plan = ctx.get('plan', {})
-        data: dict = {}
+    async def _gather(self, plan: dict) -> dict:
+        data: dict = {'mode': plan.get('mode', 'read')}
+        if plan.get('mode') == 'create_from_receipts':
+            self._gathered_data = data
+            return data
         data['summary'] = await self._et.get_expenses_summary(
             date_from=plan.get('date_from'), date_to=plan.get('date_to'),
         )
@@ -71,9 +77,12 @@ class ExpensesAgent(BaseAgent):
         self._gathered_data = data
         return data
 
-    async def _reason(self, ctx: dict) -> dict:
+    async def _reason(self) -> dict:
         data = self._gathered_data
         analysis: dict = {'escalations': [], 'flags': []}
+        if data.get('mode') == 'create_from_receipts':
+            self._escalations_list = []
+            return analysis
         summary = data.get('summary', {})
         if summary.get('pending_approval_count', 0) > 10:
             analysis['escalations'].append(
@@ -82,23 +91,135 @@ class ExpensesAgent(BaseAgent):
         self._escalations_list = analysis['escalations']
         return analysis
 
-    async def _act(self, ctx: dict) -> list:
-        return []
+    async def _act(self, reasoning: dict) -> list:
+        if self._gathered_data.get('mode') != 'create_from_receipts':
+            return []
+        receipts = getattr(self._directive.context, 'receipts', []) if self._directive else []
+        if not receipts:
+            return []
 
-    async def _report(self, ctx: dict) -> AgentReport:
+        user_id = (self._directive.context.peer_data.get('requesting_user_id')
+                   if self._directive else None)
+        employee_id = await self._et.get_employee_id_for_user(user_id)
+        if not employee_id:
+            self._escalations_list.append(
+                'No employee record found for the current user; cannot create expense report.')
+            return []
+
+        sheet_name = f'Expense Report - {_date.today().isoformat()}'
+        sheet_result = await self._et.create_expense_sheet(sheet_name, employee_id)
+        if not sheet_result.success:
+            self._escalations_list.append(f'Failed to create expense sheet: {sheet_result.error}')
+            return []
+
+        sheet_id = sheet_result.record_id
+        actions = [f'Created expense sheet "{sheet_name}" (ID {sheet_id})']
+
+        product_id = await self._et.get_default_expense_product()
+
+        for receipt in receipts:
+            parsed = await self._parse_receipt_text(
+                receipt.get('text', ''), receipt.get('filename', 'receipt'))
+            expense_result = await self._et.create_expense(
+                sheet_id=sheet_id,
+                employee_id=employee_id,
+                name=str(parsed.get('vendor', receipt.get('filename', 'Expense')))[:64],
+                total_amount=float(parsed.get('amount', 0.0)),
+                date=str(parsed.get('date') or _date.today().isoformat()),
+                product_id=product_id,
+                description=str(parsed.get('description', '')),
+            )
+            if expense_result.success:
+                actions.append(
+                    f"Added: {parsed.get('vendor', 'Unknown vendor')} "
+                    f"${float(parsed.get('amount', 0)):.2f} "
+                    f"on {parsed.get('date', 'today')}"
+                )
+                if receipt.get('b64'):
+                    await self._et.attach_receipt(
+                        'hr.expense', expense_result.record_id,
+                        receipt.get('filename', 'receipt'),
+                        receipt['b64'],
+                        receipt.get('mimetype', 'application/octet-stream'),
+                    )
+            else:
+                actions.append(
+                    f"Could not create expense for {receipt.get('filename', 'receipt')}: "
+                    f"{expense_result.error}"
+                )
+
+        self._actions_taken = actions
+        return actions
+
+    async def _parse_receipt_text(self, text: str, filename: str) -> dict:
+        fallback = {'vendor': filename, 'amount': 0.0,
+                    'date': _date.today().isoformat(), 'description': filename}
+        if not text or text.startswith('['):
+            return fallback
+
+        prompt = (
+            'Extract expense details from the following receipt text. '
+            'Return ONLY valid JSON with these keys: '
+            '"vendor" (string), "amount" (number, the total charged), '
+            '"date" (string YYYY-MM-DD, use today if absent), '
+            '"description" (string, brief expense type).\n\n'
+            f'Receipt text (first 2000 chars):\n{text[:2000]}\n\nJSON only:'
+        )
+        try:
+            resp = await self._llm.submit(
+                [{'role': 'user', 'content': prompt}],
+                caller='expenses_agent_receipt_parser',
+            )
+            raw = (resp.content or '').strip()
+            first, last = raw.find('{'), raw.rfind('}')
+            if first != -1 and last > first:
+                data = json.loads(raw[first:last + 1])
+                return {
+                    'vendor': str(data.get('vendor', filename)),
+                    'amount': float(data.get('amount', 0.0)),
+                    'date': str(data.get('date', _date.today().isoformat())),
+                    'description': str(data.get('description', '')),
+                }
+        except Exception as exc:
+            logger.warning('Receipt parse failed for %s: %s', filename, exc)
+        return fallback
+
+    async def _report(self) -> AgentReport:
         data = self._gathered_data
-        summary = data.get('summary', {})
+        directive_id = self._directive.directive_id if self._directive else ''
+
+        if data.get('mode') == 'create_from_receipts':
+            if self._actions_taken:
+                lines = '\n'.join(f'  • {a}' for a in self._actions_taken)
+                summary = (
+                    f'Expense report created successfully:\n{lines}\n\n'
+                    'The report is in draft. Please open Odoo > Expenses, '
+                    'review the entries, and click Submit to send for approval.'
+                )
+                status = 'complete'
+            else:
+                summary = ('Could not create expense report. ' +
+                           '; '.join(self._escalations_list or ['Unknown error']))
+                status = 'failed'
+            return AgentReport(
+                directive_id=directive_id, agent=self.name, status=status,
+                summary=summary, data=data,
+                escalations=self._escalations_list, actions_taken=self._actions_taken)
+
+        summary_data = data.get('summary', {})
         parts = []
-        if summary:
+        if summary_data:
             parts.append(
-                f'Expenses: {summary.get("total_expenses", 0)} records, '
-                f'total {summary.get("total_amount", 0):.2f}. '
-                f'{summary.get("pending_approval_count", 0)} pending approval.'
+                f'Expenses: {summary_data.get("total_expenses", 0)} records, '
+                f'total ${summary_data.get("total_amount", 0):.2f}. '
+                f'{summary_data.get("pending_approval_count", 0)} pending approval.'
             )
         if not parts:
             parts.append('Expenses review complete.')
-        return AgentReport(agent=self.name, summary=chr(10).join(parts),
-                           data=data, escalations=self._escalations_list, actions_taken=[])
+        return AgentReport(
+            directive_id=directive_id, agent=self.name, status='complete',
+            summary='\n'.join(parts), data=data,
+            escalations=self._escalations_list, actions_taken=[])
 
     async def _dispatch_tool(self, name: str, args: dict):
         dispatch = {
@@ -121,7 +242,8 @@ class ExpensesAgent(BaseAgent):
             if req_type == 'expenses_summary':
                 return await self._et.get_expenses_summary()
             if req_type == 'employee_expenses':
-                return {'expenses': await self._et.get_expense_by_employee(employee_id=request['employee_id'])}
+                return {'expenses': await self._et.get_expense_by_employee(
+                    employee_id=request['employee_id'])}
             return {'error': f'Unknown type: {req_type}'}
         except Exception as exc:
             return {'error': str(exc)}
@@ -131,10 +253,15 @@ class ExpensesAgent(BaseAgent):
         try:
             pending = await self._et.get_pending_approvals()
             for sheet in pending:
-                findings.append({'type': 'pending_expense_approval', 'sheet_id': sheet.get('id'),
-                                  'employee': sheet.get('employee_id', [0, ''])[1] if isinstance(sheet.get('employee_id'), list) else '',
-                                  'amount': sheet.get('total_amount', 0), 'severity': 'low'})
+                emp = sheet.get('employee_id', [0, ''])
+                findings.append({
+                    'type': 'pending_expense_approval',
+                    'sheet_id': sheet.get('id'),
+                    'employee': emp[1] if isinstance(emp, list) else '',
+                    'amount': sheet.get('total_amount', 0),
+                    'severity': 'low',
+                })
         except Exception as exc:
-            return SweepReport(agent=self.name, findings=[], actions=[], error=str(exc))
-        return SweepReport(agent=self.name, findings=findings, actions=[],
+            return SweepReport(agent=self.name, findings=[], error=str(exc))
+        return SweepReport(agent=self.name, findings=findings, actions_taken=[],
                            summary=f'Expenses sweep: {len(findings)} pending approvals.')

agent_service/agents/master_agent.py

@@ -71,7 +71,8 @@ class MasterAgent:
         # example block, so str.format would treat them as fields.
         return template.replace('{agent_list}', agent_list)
 
-    async def handle_message(self, user_id, channel_id, message, directive_id) -> MasterResponse:
+    async def handle_message(self, user_id, channel_id, message, directive_id,
+                             extra_context: dict = None) -> MasterResponse:
         try:
             user_id = int(user_id)
         except (TypeError, ValueError):
@@ -107,7 +108,8 @@ class MasterAgent:
                 await self._memory.append_message(user_id, 'assistant', msg, directive_id)
                 await self._log_directive_complete(directive_id, 'failed', msg)
                 return MasterResponse(directive_id=directive_id, response=msg, status='failed')
-            directives = await self._build_directives(intent, context, directive_id)
+            directives = await self._build_directives(intent, context, directive_id,
+                                                       user_id=user_id, extra_context=extra_context)
             reports = await self._dispatch_agents(directives)
             response_text = await self._synthesize(reports, context)
             await self._update_memory(user_id, message, response_text, reports, directive_id)
@@ -197,20 +199,26 @@ class MasterAgent:
             return AccessResult(allowed=False, denied_agents=denied)
         return AccessResult(allowed=True)
 
-    async def _build_directives(self, intent: IntentResult, context: MasterContext, directive_id) -> list:
+    async def _build_directives(self, intent: IntentResult, context: MasterContext, directive_id,
+                                user_id=None, extra_context: dict = None) -> list:
+        receipts = (extra_context or {}).get('receipts', [])
         directives = []
         for agent_key in intent.agents:
+            authorized = ['read', 'search', 'report', 'post_chatter',
+                          'send_email', 'create_non_financial', 'write_non_financial']
+            if receipts:
+                authorized.append('create_expense')
             ctx = DirectiveContext(
                 client_profile=context.knowledge,
                 recent_findings=context.operational_findings,
                 conversation_summary=chr(10).join(
                     m['content'] for m in context.conversation[-5:] if m['role'] == 'assistant'),
-                peer_data={})
+                peer_data={'requesting_user_id': user_id},
+                receipts=receipts)
             d = AgentDirective(
                 directive_id=directive_id, agent=agent_key, task=intent.intent_summary,
                 params=intent.params, context=ctx,
-                authorized_actions=['read', 'search', 'report', 'post_chatter',
-                                    'send_email', 'create_non_financial', 'write_non_financial'],
+                authorized_actions=authorized,
                 constraints={'max_amount': 5000})
             directives.append(d)
         return directives

agent_service/main.py

@@ -10,7 +10,7 @@ from fastapi.middleware.cors import CORSMiddleware
 
 from .config import get_settings
 from . import app_state
-from .routers import dispatch, approval, registry, sweep, health
+from .routers import dispatch, approval, registry, sweep, health, upload
 
 logger = logging.getLogger(__name__)
 
@@ -224,6 +224,7 @@ def create_app() -> FastAPI:
         allow_headers=['*'],
     )
     app.include_router(dispatch.router)
+    app.include_router(upload.router)
     app.include_router(approval.router)
     app.include_router(registry.router)
     app.include_router(sweep.router)

agent_service/routers/upload.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+import asyncio
+import logging
+import uuid
+from typing import List, Optional
+
+from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile, status
+
+from ..config import get_settings
+from .dispatch import DispatchResponse, _check_rate_limit, _verify_webhook_secret
+from ..tools.receipt_parser import parse_upload
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix='/upload', tags=['upload'])
+
+
+@router.post('', response_model=DispatchResponse)
+async def upload(
+    request: Request,
+    user_id: str = Form(...),
+    message: str = Form(default='Create an employee expense report from these receipts.'),
+    session_id: Optional[str] = Form(default=None),
+    files: List[UploadFile] = File(default=[]),
+):
+    _verify_webhook_secret(request)
+    _check_rate_limit(user_id)
+
+    from ..app_state import get_master_agent
+    master = get_master_agent()
+    if master is None:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                            detail='Agent service not ready')
+
+    receipts: list[dict] = []
+    for f in files:
+        data = await f.read()
+        filename = f.filename or 'receipt'
+        try:
+            parsed = parse_upload(filename, data)
+            receipts.extend(parsed)
+            logger.info('upload: parsed %s → %d receipt(s)', filename, len(parsed))
+        except Exception as exc:
+            logger.warning('upload: parse failed for %s: %s', filename, exc)
+
+    if not receipts:
+        logger.warning('upload: no parseable receipts found in upload from user_id=%s', user_id)
+
+    directive_id = session_id or uuid.uuid4().hex
+    extra_context = {'receipts': receipts, 'user_id': user_id}
+
+    settings = get_settings()
+    timeout = settings.directive_timeout_minutes * 60
+
+    try:
+        response = await asyncio.wait_for(
+            master.handle_message(
+                user_id=user_id,
+                channel_id=None,
+                message=message,
+                directive_id=directive_id,
+                extra_context=extra_context,
+            ),
+            timeout=timeout,
+        )
+    except asyncio.TimeoutError:
+        raise HTTPException(
+            status_code=status.HTTP_504_GATEWAY_TIMEOUT,
+            detail=f'Directive timed out after {settings.directive_timeout_minutes}m',
+        )
+    except Exception as exc:
+        logger.exception('upload error user=%s: %s', user_id, exc)
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(exc))
+
+    return DispatchResponse(
+        directive_id=response.directive_id,
+        reply=response.response,
+        escalations=response.escalations,
+        actions_taken=response.actions_taken,
+        session_id=session_id,
+    )

agent_service/tools/expenses_tools.py

@@ -84,3 +84,64 @@ class ExpensesTools:
     async def post_chatter_note(self, model: str, record_id: int, note: str) -> bool:
         await self._o.call(model, 'message_post', [[record_id]], {'body': note, 'message_type': 'comment'})
         return True
+
+    async def get_employee_id_for_user(self, user_id) -> int | None:
+        if not user_id:
+            return None
+        try:
+            records = await self._o.search_read(
+                'hr.employee', [('user_id', '=', int(user_id))], ['id', 'name'], limit=1)
+            return records[0]['id'] if records else None
+        except Exception as exc:
+            logger.warning('get_employee_id_for_user failed user_id=%s: %s', user_id, exc)
+            return None
+
+    async def get_default_expense_product(self) -> int | None:
+        try:
+            records = await self._o.search_read(
+                'product.product',
+                [('can_be_expensed', '=', True), ('type', '=', 'service')],
+                ['id', 'name'], limit=1)
+            return records[0]['id'] if records else None
+        except Exception as exc:
+            logger.warning('get_default_expense_product failed: %s', exc)
+            return None
+
+    async def create_expense_sheet(self, name: str, employee_id: int):
+        return await self._o.create('hr.expense.sheet', {
+            'name': name,
+            'employee_id': employee_id,
+        })
+
+    async def create_expense(self, sheet_id: int, employee_id: int, name: str,
+                              total_amount: float, date: str, product_id: int = None,
+                              description: str = ''):
+        vals: dict = {
+            'name': name,
+            'employee_id': employee_id,
+            'sheet_id': sheet_id,
+            'total_amount': total_amount,
+            'quantity': 1.0,
+        }
+        if date:
+            vals['date'] = date
+        if product_id:
+            vals['product_id'] = product_id
+        if description:
+            vals['description'] = description
+        return await self._o.create('hr.expense', vals)
+
+    async def attach_receipt(self, model: str, record_id: int, filename: str,
+                              file_b64: str, mimetype: str) -> bool:
+        try:
+            await self._o.create('ir.attachment', {
+                'name': filename,
+                'datas': file_b64,
+                'res_model': model,
+                'res_id': record_id,
+                'mimetype': mimetype,
+            })
+            return True
+        except Exception as exc:
+            logger.warning('attach_receipt failed %s/%s: %s', model, record_id, exc)
+            return False

agent_service/tools/receipt_parser.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+import base64
+import io
+import logging
+import zipfile
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_MIME = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.png': 'image/png', '.gif': 'image/gif',
+    '.bmp': 'image/bmp', '.tiff': 'image/tiff', '.tif': 'image/tiff',
+    '.webp': 'image/webp', '.pdf': 'application/pdf',
+    '.html': 'text/html', '.htm': 'text/html',
+    '.txt': 'text/plain', '.zip': 'application/zip',
+}
+
+_IMAGE_EXTS = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.tif', '.webp'}
+
+
+def parse_upload(filename: str, data: bytes) -> list[dict]:
+    """
+    Parse one uploaded file into a list of receipt dicts.
+    ZIP files are recursively unpacked; all other types return a single entry.
+    Each dict: {filename, text, b64, mimetype}
+    """
+    ext = Path(filename).suffix.lower()
+    if ext == '.zip':
+        return _extract_zip(filename, data)
+
+    b64 = base64.b64encode(data).decode()
+    mimetype = _MIME.get(ext, 'application/octet-stream')
+
+    if ext in _IMAGE_EXTS:
+        text = _ocr_image(data, filename)
+    elif ext == '.pdf':
+        text = _extract_pdf(data, filename)
+    elif ext in ('.html', '.htm'):
+        text = _extract_html(data, filename)
+    elif ext == '.txt':
+        text = data.decode('utf-8', errors='replace')
+    else:
+        try:
+            text = data.decode('utf-8', errors='replace')
+        except Exception:
+            text = f'[Binary file: {filename}]'
+
+    return [{'filename': filename, 'text': text, 'b64': b64, 'mimetype': mimetype}]
+
+
+def _extract_zip(zip_filename: str, data: bytes) -> list[dict]:
+    results = []
+    try:
+        with zipfile.ZipFile(io.BytesIO(data)) as zf:
+            for member in zf.namelist():
+                if member.endswith('/'):
+                    continue
+                try:
+                    member_data = zf.read(member)
+                    results.extend(parse_upload(Path(member).name, member_data))
+                except Exception as exc:
+                    logger.warning('receipt_parser: zip member %s failed: %s', member, exc)
+    except Exception as exc:
+        logger.error('receipt_parser: zip %s failed: %s', zip_filename, exc)
+    return results
+
+
+def _ocr_image(data: bytes, filename: str) -> str:
+    try:
+        from PIL import Image
+        import pytesseract
+        img = Image.open(io.BytesIO(data))
+        return pytesseract.image_to_string(img).strip()
+    except ImportError:
+        logger.warning('pytesseract/Pillow not installed — OCR unavailable for %s', filename)
+        return f'[Image: {filename} — install pytesseract+Pillow for OCR]'
+    except Exception as exc:
+        logger.warning('OCR failed for %s: %s', filename, exc)
+        return f'[Image: {filename} — OCR failed: {exc}]'
+
+
+def _extract_pdf(data: bytes, filename: str) -> str:
+    try:
+        import pdfplumber
+        parts = []
+        with pdfplumber.open(io.BytesIO(data)) as pdf:
+            for page in pdf.pages:
+                t = page.extract_text()
+                if t:
+                    parts.append(t)
+        return '\n'.join(parts).strip()
+    except ImportError:
+        logger.warning('pdfplumber not installed — PDF extraction unavailable for %s', filename)
+        return f'[PDF: {filename} — install pdfplumber for text extraction]'
+    except Exception as exc:
+        logger.warning('PDF extraction failed for %s: %s', filename, exc)
+        return f'[PDF: {filename} — extraction failed: {exc}]'
+
+
+def _extract_html(data: bytes, filename: str) -> str:
+    try:
+        from html.parser import HTMLParser
+
+        class _TextExtractor(HTMLParser):
+            def __init__(self):
+                super().__init__()
+                self._parts: list[str] = []
+                self._skip = False
+
+            def handle_starttag(self, tag, attrs):
+                if tag in ('script', 'style'):
+                    self._skip = True
+
+            def handle_endtag(self, tag):
+                if tag in ('script', 'style'):
+                    self._skip = False
+
+            def handle_data(self, data):
+                if not self._skip:
+                    s = data.strip()
+                    if s:
+                        self._parts.append(s)
+
+            def text(self):
+                return ' '.join(self._parts)
+
+        parser = _TextExtractor()
+        parser.feed(data.decode('utf-8', errors='replace'))
+        return parser.text()
+    except Exception as exc:
+        logger.warning('HTML extraction failed for %s: %s', filename, exc)
+        return f'[HTML: {filename} — extraction failed: {exc}]'