changes

fusion_accounting/services/__init__.py

@@ -0,0 +1,5 @@
+from . import adapters
+from . import tools
+from . import prompts
+from . import agent
+from . import scoring

fusion_accounting/services/adapters/__init__.py

@@ -0,0 +1,2 @@
+from . import claude
+from . import openai_adapter

fusion_accounting/services/adapters/claude.py

@@ -0,0 +1,141 @@
+import json
+import logging
+
+from odoo import models, api, _
+from odoo.exceptions import UserError
+
+_logger = logging.getLogger(__name__)
+
+try:
+    import anthropic as anthropic_sdk
+except ImportError:
+    anthropic_sdk = None
+
+
+class FusionAccountingAdapterClaude(models.AbstractModel):
+    _name = 'fusion.accounting.adapter.claude'
+    _description = 'Claude AI Adapter'
+
+    def _get_client(self):
+        if anthropic_sdk is None:
+            raise UserError(_("The 'anthropic' Python package is not installed."))
+        try:
+            key = self.env['fusion.api.service'].get_api_key(
+                provider_type='anthropic',
+                consumer='fusion_accounting',
+                feature='chat_with_tools',
+            )
+        except Exception:
+            ICP = self.env['ir.config_parameter'].sudo()
+            key = ICP.get_param('fusion_accounting.anthropic_api_key', '')
+            if not key:
+                raise UserError(_("No Anthropic API key configured."))
+        return anthropic_sdk.Anthropic(api_key=key)
+
+    def _get_model_name(self):
+        ICP = self.env['ir.config_parameter'].sudo()
+        return ICP.get_param('fusion_accounting.claude_model', 'claude-sonnet-4-6')
+
+    def _format_tools(self, tools):
+        formatted = []
+        for tool in tools:
+            t = {
+                'name': tool['name'],
+                'description': tool['description'],
+                'input_schema': tool.get('parameters', {'type': 'object', 'properties': {}}),
+            }
+            formatted.append(t)
+        return formatted
+
+    def _supports_extended_thinking(self, model):
+        return '4-6' in model or '4-5' in model or '4-1' in model or '4-0' in model
+
+    def call_with_tools(self, system_prompt, messages, tools=None):
+        client = self._get_client()
+        model = self._get_model_name()
+
+        api_messages = []
+        for msg in messages:
+            if msg['role'] in ('user', 'assistant'):
+                api_messages.append(msg)
+
+        kwargs = {
+            'model': model,
+            'max_tokens': 16384,
+            'system': system_prompt,
+            'messages': api_messages,
+        }
+        if tools:
+            kwargs['tools'] = self._format_tools(tools)
+
+        if self._supports_extended_thinking(model) and tools:
+            kwargs['thinking'] = {
+                'type': 'enabled',
+                'budget_tokens': 8192,
+            }
+
+        try:
+            response = client.messages.create(**kwargs)
+        except anthropic_sdk.BadRequestError as e:
+            if 'thinking' in str(e).lower():
+                kwargs.pop('thinking', None)
+                response = client.messages.create(**kwargs)
+            else:
+                raise UserError(_("Claude API error: %s", str(e)))
+        except Exception as e:
+            _logger.error("Claude API error: %s", e)
+            raise UserError(_("Claude API error: %s", str(e)))
+
+        text_parts = []
+        tool_calls = []
+        thinking_text = []
+        for block in response.content:
+            if block.type == 'text':
+                text_parts.append(block.text)
+            elif block.type == 'tool_use':
+                tool_calls.append({
+                    'id': block.id,
+                    'name': block.name,
+                    'arguments': block.input,
+                })
+            elif block.type == 'thinking':
+                thinking_text.append(block.thinking)
+
+        if thinking_text:
+            _logger.debug("Claude thinking: %s", thinking_text[0][:500])
+
+        return {
+            'text': '\n'.join(text_parts),
+            'tool_calls': tool_calls if tool_calls else None,
+            'tokens_in': response.usage.input_tokens,
+            'tokens_out': response.usage.output_tokens,
+            'stop_reason': response.stop_reason,
+            'raw_content': response.content,
+        }
+
+    def append_tool_results(self, messages, ai_response, tool_results):
+        assistant_content = []
+        for block in ai_response.get('raw_content', []):
+            if hasattr(block, 'type'):
+                if block.type == 'text':
+                    assistant_content.append({'type': 'text', 'text': block.text})
+                elif block.type == 'tool_use':
+                    assistant_content.append({
+                        'type': 'tool_use',
+                        'id': block.id,
+                        'name': block.name,
+                        'input': block.input,
+                    })
+
+        messages.append({'role': 'assistant', 'content': assistant_content})
+
+        tool_result_content = []
+        for tr in tool_results:
+            tool_result_content.append({
+                'type': 'tool_result',
+                'tool_use_id': tr['tool_call_id'],
+                'content': tr['result'],
+            })
+        messages.append({'role': 'user', 'content': tool_result_content})
+
+        return messages

fusion_accounting/services/adapters/openai_adapter.py

@@ -0,0 +1,137 @@
+import json
+import logging
+
+from odoo import models, api, _
+from odoo.exceptions import UserError
+
+_logger = logging.getLogger(__name__)
+
+try:
+    from openai import OpenAI
+except ImportError:
+    OpenAI = None
+
+
+class FusionAccountingAdapterOpenAI(models.AbstractModel):
+    _name = 'fusion.accounting.adapter.openai'
+    _description = 'OpenAI AI Adapter'
+
+    def _get_client(self):
+        if OpenAI is None:
+            raise UserError(_("The 'openai' Python package is not installed."))
+        try:
+            key = self.env['fusion.api.service'].get_api_key(
+                provider_type='openai',
+                consumer='fusion_accounting',
+                feature='chat_with_tools',
+            )
+        except Exception:
+            ICP = self.env['ir.config_parameter'].sudo()
+            key = ICP.get_param('fusion_accounting.openai_api_key', '')
+            if not key:
+                raise UserError(_("No OpenAI API key configured."))
+        return OpenAI(api_key=key)
+
+    def _get_model_name(self):
+        ICP = self.env['ir.config_parameter'].sudo()
+        return ICP.get_param('fusion_accounting.openai_model', 'gpt-5.4-mini')
+
+    def _format_tools(self, tools):
+        formatted = []
+        for tool in tools:
+            formatted.append({
+                'type': 'function',
+                'function': {
+                    'name': tool['name'],
+                    'description': tool['description'],
+                    'parameters': tool.get('parameters', {'type': 'object', 'properties': {}}),
+                },
+            })
+        return formatted
+
+    def _is_reasoning_model(self, model):
+        return model.startswith('o1') or model.startswith('o3') or model.startswith('o4')
+
+    def call_with_tools(self, system_prompt, messages, tools=None):
+        client = self._get_client()
+        model = self._get_model_name()
+        is_reasoning = self._is_reasoning_model(model)
+
+        if is_reasoning:
+            api_messages = [{'role': 'developer', 'content': system_prompt}]
+        else:
+            api_messages = [{'role': 'system', 'content': system_prompt}]
+        for msg in messages:
+            if msg['role'] in ('user', 'assistant', 'tool'):
+                api_messages.append(msg)
+
+        kwargs = {
+            'model': model,
+            'messages': api_messages,
+        }
+        if is_reasoning:
+            kwargs['max_completion_tokens'] = 16384
+            kwargs['reasoning_effort'] = 'medium'
+        else:
+            kwargs['max_tokens'] = 4096
+
+        if tools:
+            kwargs['tools'] = self._format_tools(tools)
+
+        try:
+            response = client.chat.completions.create(**kwargs)
+        except Exception as e:
+            _logger.error("OpenAI API error: %s", e)
+            raise UserError(_("OpenAI API error: %s", str(e)))
+
+        choice = response.choices[0]
+        message = choice.message
+
+        tool_calls = []
+        if message.tool_calls:
+            for tc in message.tool_calls:
+                try:
+                    args = json.loads(tc.function.arguments)
+                except (json.JSONDecodeError, TypeError):
+                    _logger.warning("Malformed tool args from OpenAI: %s", tc.function.arguments)
+                    args = {}
+                tool_calls.append({
+                    'id': tc.id,
+                    'name': tc.function.name,
+                    'arguments': args,
+                })
+
+        return {
+            'text': message.content or '',
+            'tool_calls': tool_calls if tool_calls else None,
+            'tokens_in': response.usage.prompt_tokens,
+            'tokens_out': response.usage.completion_tokens,
+            'stop_reason': choice.finish_reason,
+            'raw_message': message,
+        }
+
+    def append_tool_results(self, messages, ai_response, tool_results):
+        raw_msg = ai_response.get('raw_message')
+        assistant_msg = {'role': 'assistant', 'content': raw_msg.content or ''}
+        if raw_msg.tool_calls:
+            assistant_msg['tool_calls'] = [
+                {
+                    'id': tc.id,
+                    'type': 'function',
+                    'function': {
+                        'name': tc.function.name,
+                        'arguments': tc.function.arguments,
+                    },
+                }
+                for tc in raw_msg.tool_calls
+            ]
+        messages.append(assistant_msg)
+
+        for tr in tool_results:
+            messages.append({
+                'role': 'tool',
+                'tool_call_id': tr['tool_call_id'],
+                'content': tr['result'],
+            })
+
+        return messages

fusion_accounting/services/agent.py

@@ -0,0 +1,315 @@
+import json
+import logging
+import time
+
+from odoo import models, fields, api, _
+from odoo.exceptions import UserError
+
+_logger = logging.getLogger(__name__)
+
+
+class FusionAccountingAgent(models.AbstractModel):
+    _name = 'fusion.accounting.agent'
+    _description = 'Fusion Accounting AI Agent Orchestrator'
+
+    def _get_config(self, key, default=None):
+        ICP = self.env['ir.config_parameter'].sudo()
+        return ICP.get_param(f'fusion_accounting.{key}', default)
+
+    def _get_adapter(self):
+        provider = self._get_config('ai_provider', 'claude')
+        if provider == 'claude':
+            return self.env['fusion.accounting.adapter.claude']
+        return self.env['fusion.accounting.adapter.openai']
+
+    def _get_tool_registry(self):
+        return self.env['fusion.accounting.tool'].search([('active', '=', True)])
+
+    def _get_tools_for_user(self, user=None):
+        user = user or self.env.user
+        tools = self._get_tool_registry()
+        filtered = self.env['fusion.accounting.tool']
+        for tool in tools:
+            if not tool.required_groups:
+                filtered |= tool
+                continue
+            group_xmlids = [g.strip() for g in tool.required_groups.split(',') if g.strip()]
+            if all(user.has_group(g) for g in group_xmlids):
+                filtered |= tool
+        return filtered
+
+    def _build_tool_definitions(self, tools):
+        definitions = []
+        for tool in tools:
+            defn = {
+                'name': tool.name,
+                'description': tool.description,
+            }
+            if tool.parameters_schema:
+                try:
+                    defn['parameters'] = json.loads(tool.parameters_schema)
+                except json.JSONDecodeError:
+                    defn['parameters'] = {'type': 'object', 'properties': {}}
+            else:
+                defn['parameters'] = {'type': 'object', 'properties': {}}
+            definitions.append(defn)
+        return definitions
+
+    def _load_rules(self, domain=None):
+        rule_domain = [('active', '=', True), ('company_id', '=', self.env.company.id)]
+        if domain:
+            rule_domain.append(('rule_type', '=', domain))
+        rules = self.env['fusion.accounting.rule'].search(rule_domain, order='sequence')
+        admin_rules = rules.filtered(lambda r: r.created_by == 'admin')
+        ai_auto = rules.filtered(lambda r: r.created_by == 'ai' and r.approval_tier == 'auto')
+        ai_pending = rules.filtered(lambda r: r.created_by == 'ai' and r.approval_tier == 'needs_approval')
+        return admin_rules | ai_auto | ai_pending
+
+    def _load_match_history(self, domain=None, limit=None):
+        limit = limit or int(self._get_config('history_in_prompt', '50'))
+        history_domain = [('company_id', '=', self.env.company.id)]
+        if domain:
+            history_domain.append(('tool_name', 'ilike', domain))
+        return self.env['fusion.accounting.match.history'].search(
+            history_domain, limit=limit, order='proposed_at desc',
+        )
+
+    def _build_system_prompt(self, rules, history, context=None, domain=None):
+        from .prompts.system_prompt import build_system_prompt
+        from .prompts.domain_prompts import get_domain_prompt
+        base = build_system_prompt(rules, history, context)
+        if domain:
+            domain_prompt = get_domain_prompt(domain)
+            if domain_prompt:
+                base = f"{base}\n\n{domain_prompt}"
+        return base
+
+    def _execute_tool(self, tool_name, params, session_id=None):
+        from .tools import TOOL_DISPATCH
+        if tool_name not in TOOL_DISPATCH:
+            return {'error': f'Unknown tool: {tool_name}'}
+        try:
+            result = TOOL_DISPATCH[tool_name](self.env, params)
+            return result
+        except Exception as e:
+            _logger.error("Tool execution error (%s): %s", tool_name, e)
+            return {'error': str(e)}
+
+    def _log_match_history(self, session, tool_name, params, result, reasoning='',
+                           confidence=0.0, rule=None, tier='1'):
+        vals = {
+            'session_id': session.id if session else False,
+            'tool_name': tool_name,
+            'tool_params': json.dumps(params) if params else '{}',
+            'tool_result': json.dumps(result) if result else '{}',
+            'ai_reasoning': reasoning,
+            'ai_confidence': confidence,
+            'rule_id': rule.id if rule else False,
+            'proposed_at': fields.Datetime.now(),
+            'decision': 'auto' if tier in ('1', '2') else 'pending',
+            'company_id': self.env.company.id,
+        }
+        return self.env['fusion.accounting.match.history'].sudo().create(vals)
+
+    def chat(self, session_id, user_message, context=None):
+        session = self.env['fusion.accounting.session'].browse(session_id)
+        if not session.exists():
+            raise UserError(_("Session not found."))
+
+        adapter = self._get_adapter()
+        tools = self._get_tools_for_user()
+        tool_definitions = self._build_tool_definitions(tools)
+        rules = self._load_rules()
+        history = self._load_match_history()
+        system_prompt = self._build_system_prompt(
+            rules, history, context, domain=session.context_domain,
+        )
+
+        messages_json = json.loads(session.message_ids_json or '[]')
+        messages_json.append({'role': 'user', 'content': user_message})
+
+        max_turns = max(int(self._get_config('max_tool_calls', '20')), 1)
+        total_tokens_in = 0
+        total_tokens_out = 0
+        response = {'text': '', 'tool_calls': None}
+
+        for turn in range(max_turns):
+            response = adapter.call_with_tools(
+                system_prompt=system_prompt,
+                messages=messages_json,
+                tools=tool_definitions,
+            )
+            total_tokens_in += response.get('tokens_in', 0)
+            total_tokens_out += response.get('tokens_out', 0)
+
+            if response.get('tool_calls'):
+                tool_results = []
+                for tc in response['tool_calls']:
+                    tool_name = tc['name']
+                    tool_params = tc.get('arguments', {})
+                    tool_rec = tools.filtered(lambda t: t.name == tool_name)
+                    tier = tool_rec.tier if tool_rec else '1'
+
+                    if tier == '3':
+                        history_rec = self._log_match_history(
+                            session, tool_name, tool_params, None,
+                            reasoning=tc.get('reasoning', ''),
+                            confidence=tc.get('confidence', 0.0),
+                            tier='3',
+                        )
+                        tool_results.append({
+                            'tool_call_id': tc.get('id', ''),
+                            'result': json.dumps({
+                                'status': 'pending_approval',
+                                'match_history_id': history_rec.id,
+                                'message': f'Action requires user approval. Match history ID: {history_rec.id}',
+                            }),
+                        })
+                    else:
+                        result = self._execute_tool(tool_name, tool_params, session.id)
+                        self._log_match_history(
+                            session, tool_name, tool_params, result,
+                            reasoning=tc.get('reasoning', ''),
+                            tier=tier,
+                        )
+                        tool_results.append({
+                            'tool_call_id': tc.get('id', ''),
+                            'result': json.dumps(result) if not isinstance(result, str) else result,
+                        })
+                        try:
+                            self._check_rule_proposal(tool_name, tool_params, session)
+                        except Exception:
+                            _logger.exception("Error in _check_rule_proposal for tool %s", tool_name)
+
+                messages_json = adapter.append_tool_results(
+                    messages_json, response, tool_results,
+                )
+                session.tool_call_count += len(tool_results)
+            else:
+                assistant_text = response.get('text', '')
+                messages_json.append({'role': 'assistant', 'content': assistant_text})
+                break
+        else:
+            # Loop exhausted — force a final text response without tools
+            try:
+                response = adapter.call_with_tools(
+                    system_prompt=system_prompt,
+                    messages=messages_json,
+                    tools=[],
+                )
+                total_tokens_in += response.get('tokens_in', 0)
+                total_tokens_out += response.get('tokens_out', 0)
+                messages_json.append({
+                    'role': 'assistant',
+                    'content': response.get('text', 'I reached the maximum number of steps. Please continue the conversation.'),
+                })
+            except Exception:
+                _logger.warning("Failed to get final summary after max tool calls")
+
+        session.write({
+            'message_ids_json': json.dumps(messages_json),
+            'token_count_in': session.token_count_in + total_tokens_in,
+            'token_count_out': session.token_count_out + total_tokens_out,
+            'ai_provider': self._get_config('ai_provider', 'claude'),
+            'ai_model': adapter._get_model_name(),
+        })
+
+        pending = self.env['fusion.accounting.match.history'].search([
+            ('session_id', '=', session.id),
+            ('decision', '=', 'pending'),
+        ])
+
+        return {
+            'text': response.get('text', ''),
+            'pending_approvals': [{
+                'id': p.id,
+                'tool_name': p.tool_name,
+                'params': p.tool_params,
+                'reasoning': p.ai_reasoning,
+                'confidence': p.ai_confidence,
+                'amount': p.amount,
+            } for p in pending],
+            'session_id': session.id,
+        }
+
+    def approve_action(self, match_history_id):
+        history = self.env['fusion.accounting.match.history'].browse(match_history_id)
+        if not history.exists() or history.decision != 'pending':
+            raise UserError(_("Action not found or already decided."))
+
+        params = json.loads(history.tool_params or '{}')
+        result = self._execute_tool(history.tool_name, params, history.session_id.id)
+
+        history.write({
+            'decision': 'approved',
+            'decided_at': fields.Datetime.now(),
+            'decided_by': self.env.user.id,
+            'tool_result': json.dumps(result) if not isinstance(result, str) else result,
+        })
+        if history.rule_id:
+            history.rule_id.sudo()._record_decision(approved=True)
+
+        return result
+
+    def _check_rule_proposal(self, tool_name, params, session):
+        """Detect repeated patterns and propose new rules when 3+ identical matches."""
+        recent = self.env['fusion.accounting.match.history'].search([
+            ('tool_name', '=', tool_name),
+            ('decision', 'in', ('approved', 'auto')),
+            ('company_id', '=', self.env.company.id),
+        ], limit=20, order='proposed_at desc')
+
+        if len(recent) < 3:
+            return
+
+        from collections import Counter
+        param_keys = []
+        for h in recent:
+            try:
+                p = json.loads(h.tool_params or '{}')
+                key_parts = []
+                for k in sorted(p.keys()):
+                    if k not in ('limit', 'date_from', 'date_to'):
+                        key_parts.append(f'{k}={json.dumps(p[k], sort_keys=True)}')
+                if key_parts:
+                    param_keys.append('|'.join(key_parts))
+            except json.JSONDecodeError:
+                continue
+
+        counts = Counter(param_keys)
+        for pattern, count in counts.most_common(3):
+            if count < 3:
+                break
+            existing = self.env['fusion.accounting.rule'].search([
+                ('match_logic', 'ilike', pattern[:50]),
+                ('company_id', '=', self.env.company.id),
+            ], limit=1)
+            if existing:
+                continue
+
+            self.env['fusion.accounting.rule'].create({
+                'name': f'AI Pattern: {tool_name} ({pattern[:40]})',
+                'rule_type': 'match',
+                'description': f'Automatically detected pattern from {count} approved uses of {tool_name}.',
+                'match_logic': f'When using {tool_name} with parameters matching: {pattern}',
+                'created_by': 'ai',
+                'approval_tier': 'needs_approval',
+                'company_id': self.env.company.id,
+            })
+            _logger.info("AI proposed rule for pattern: %s (%d matches)", tool_name, count)
+
+    def reject_action(self, match_history_id, reason=''):
+        history = self.env['fusion.accounting.match.history'].browse(match_history_id)
+        if not history.exists() or history.decision != 'pending':
+            raise UserError(_("Action not found or already decided."))
+
+        history.write({
+            'decision': 'rejected',
+            'decided_at': fields.Datetime.now(),
+            'decided_by': self.env.user.id,
+            'rejection_reason': reason,
+        })
+        if history.rule_id:
+            history.rule_id.sudo()._record_decision(approved=False)
+
+        return {'status': 'rejected', 'reason': reason}

fusion_accounting/services/prompts/__init__.py

@@ -0,0 +1,2 @@
+from . import system_prompt
+from . import domain_prompts

fusion_accounting/services/prompts/domain_prompts.py

@@ -0,0 +1,109 @@
+DOMAIN_PROMPTS = {
+    'bank_reconciliation': """
+BANK RECONCILIATION CONTEXT:
+You are helping with bank statement reconciliation. Key concepts:
+- Bank statement lines (account.bank.statement.line) represent transactions from the bank feed.
+- Each line needs to be matched to one or more journal items (account.move.line).
+- Matching is done via set_line_bank_statement_line(move_line_ids).
+- Fee differences (e.g., Elavon card processing fees) should be allocated to the fee account.
+- Weekend batches may combine multiple days of card payments.
+- Always verify amounts before proposing a match.
+""",
+
+    'hst_management': """
+HST/GST MANAGEMENT CONTEXT:
+You are helping with Canadian HST/GST tax management.
+- HST Collected is tracked on account 2005 (credit balance = liability).
+- Input Tax Credits (ITCs) are on account 2006 (debit balance = asset).
+- Net HST = Collected - ITCs. Positive means owing to CRA.
+- Quarterly filing periods. Check for missing tax on invoices/bills.
+- All vendor bills should have ITCs unless explicitly exempt.
+""",
+
+    'accounts_receivable': """
+ACCOUNTS RECEIVABLE CONTEXT:
+- AR aging: current, 1-30, 31-60, 61-90, 90+ days overdue.
+- Follow-up actions escalate by aging bucket.
+- Payments should be matched to specific invoices.
+- Unmatched payments sit on the Outstanding Receipts account (1122).
+""",
+
+    'accounts_payable': """
+ACCOUNTS PAYABLE CONTEXT:
+- AP aging mirrors AR: current through 90+ days.
+- Watch for duplicate bills (same vendor + amount + date).
+- Bills should match purchase orders when applicable.
+- Tax on bills should match the vendor's fiscal position.
+""",
+
+    'journal_review': """
+JOURNAL REVIEW CONTEXT:
+- Check for wrong-direction balances (e.g., expense account with credit balance).
+- Detect duplicate entries (same partner + amount + date + journal).
+- Flag entries on unlikely accounts (revenue on a tax account, etc.).
+- Sequence gaps may indicate deleted entries.
+- Draft entries older than 30 days should be reviewed.
+""",
+
+    'month_end': """
+MONTH-END CLOSE CONTEXT:
+- Aggregate all domain checks into a close checklist.
+- Verify all bank reconciliations are current.
+- Check accrual account balances (vacation, sick leave, etc.).
+- Verify no entries exist after lock date.
+- Run hash integrity check.
+- Produce period trial balance summary.
+""",
+
+    'payroll_verification': """
+PAYROLL VERIFICATION CONTEXT:
+- Cross-reference payroll journal entries to bank statement cheques.
+- Verify CPP, EI, and income tax deductions against CRA rate tables.
+- Check CRA remittance account balance vs payments made.
+""",
+
+    'inventory': """
+INVENTORY & COGS CONTEXT:
+- Stock In Hand tracked on account 1069.
+- Price differences on account 5010 (PO price vs bill price).
+- COGS ratio by product category helps spot anomalies.
+- Large inventory adjustments need review.
+""",
+
+    'adp': """
+ADP RECONCILIATION CONTEXT:
+- ADP Receivable tracked on account 1101.
+- ADP invoices have customer portion + ADP portion = total.
+- Government deposits should match ADP invoices.
+""",
+
+    'reporting': """
+FINANCIAL REPORTING CONTEXT:
+- Reports use Odoo's account.report engine.
+- Available: P&L, Balance Sheet, Trial Balance, Cash Flow.
+- Period comparison available for trend analysis.
+- Export to PDF or XLSX for external distribution.
+""",
+
+    'audit': """
+AUDIT & INTEGRITY CONTEXT:
+- Run comprehensive checks on posted entries.
+- Verify hash chain integrity on journals.
+- Check sequence continuity.
+- Flag entries with chatter messages for review tracking.
+- Audit status per account: todo / reviewed / supervised / anomaly.
+""",
+
+    'payroll_management': """
+PAYROLL MANAGEMENT CONTEXT:
+- Parse pasted payroll summaries from QBO or fusion_payroll.
+- Create payroll journal entries with proper debit/credit lines.
+- Match payroll cheques to bank statement lines.
+- Calculate CRA obligations (CPP employer + employee, EI, income tax).
+- Prepare CRA remittance payment entries.
+""",
+}
+
+
+def get_domain_prompt(domain):
+    return DOMAIN_PROMPTS.get(domain, '')

fusion_accounting/services/prompts/system_prompt.py

@@ -0,0 +1,98 @@
+import json
+
+
+def build_system_prompt(rules, history, context=None):
+    parts = [
+        CORE_SYSTEM_PROMPT,
+        _build_rules_section(rules),
+        _build_history_section(history),
+    ]
+    if context:
+        parts.append(_build_context_section(context))
+    return '\n\n'.join(p for p in parts if p)
+
+
+CORE_SYSTEM_PROMPT = """You are Fusion AI, an expert accounting co-pilot embedded in Odoo 19.
+You assist with bank reconciliation, HST/GST management, AR/AP analysis, journal review,
+month-end close, payroll, inventory, ADP reconciliation, financial reporting, and auditing.
+
+BEHAVIOUR:
+- Use tools to query and act on Odoo data. Never invent financial figures.
+- For Tier 1 tools: execute immediately and report results.
+- For Tier 2 tools: execute and log. Inform the user what was done.
+- For Tier 3 tools: propose the action with clear reasoning. The user must approve.
+- When proposing a Tier 3 action, explain: what you want to do, why, the amounts involved, and your confidence level.
+- Apply Fusion Rules (below) before general reasoning.
+- Reference match history for patterns the user has approved/rejected before.
+- Use Canadian English. Format monetary amounts with $ and two decimals.
+- When you encounter ambiguity, ask clarifying questions rather than guessing.
+
+RESPONSE FORMATTING:
+- Use rich Markdown formatting in your responses. The chat renders Markdown as HTML.
+- Use **bold** for account names, amounts, and key terms.
+- Use ## and ### headers to organize sections in longer responses.
+- Use Markdown tables for tabular data (| col1 | col2 | format).
+- Use bullet lists (- item) for findings, issues, and action items.
+- Use numbered lists (1. item) for sequential steps or ranked items.
+- Use `code` for account codes, reference numbers, and technical IDs.
+- Use --- horizontal rules to separate sections in long reports.
+
+LINKING TO ODOO RECORDS:
+- When referencing specific records, include clickable Odoo links.
+- Journal entries: [INV/2026/00123](/odoo/accounting/123) where 123 is the move ID.
+- Partners: [Customer Name](/odoo/contacts/456) where 456 is the partner ID.
+- Accounts: reference by code in bold, e.g. **1001 - Cash**.
+- Bank statement lines: mention the date, reference, and amount clearly.
+- When tool results include record IDs, always link them.
+
+TOOL CALLING:
+- Call tools by name with the required parameters.
+- You may call multiple tools in sequence to gather data before proposing an action.
+- Do not exceed the maximum tool calls per turn.
+- When presenting tool results, format them richly with tables, bold amounts, and links.
+"""
+
+
+def _build_rules_section(rules):
+    if not rules:
+        return ''
+    lines = ['ACTIVE FUSION RULES:']
+    for rule in rules:
+        priority = 'ADMIN' if rule.created_by == 'admin' else 'AI'
+        tier = 'auto' if rule.approval_tier == 'auto' else 'needs-approval'
+        lines.append(
+            f'- [{priority}/{tier}] {rule.name} ({rule.rule_type}): '
+            f'{rule.description or rule.match_logic or "No description"}'
+        )
+        if rule.match_logic:
+            lines.append(f'  Match logic: {rule.match_logic}')
+    return '\n'.join(lines)
+
+
+def _build_history_section(history):
+    if not history:
+        return ''
+    lines = ['RECENT MATCH HISTORY (learn from these patterns):']
+    for h in history[:50]:
+        status = h.decision
+        reason = ''
+        if h.rejection_reason:
+            reason = f' (reason: {h.rejection_reason})'
+        lines.append(
+            f'- {h.tool_name}: {status}{reason} '
+            f'[confidence={h.ai_confidence:.0%}]'
+        )
+        if h.ai_reasoning:
+            lines.append(f'  Reasoning: {h.ai_reasoning[:200]}')
+    return '\n'.join(lines)
+
+
+def _build_context_section(context):
+    if not context:
+        return ''
+    if isinstance(context, dict):
+        parts = ['CURRENT CONTEXT:']
+        for k, v in context.items():
+            parts.append(f'- {k}: {v}')
+        return '\n'.join(parts)
+    return f'CURRENT CONTEXT: {context}'

fusion_accounting/services/scoring.py

@@ -0,0 +1,61 @@
+import logging
+
+from odoo import models, api
+
+_logger = logging.getLogger(__name__)
+
+
+class FusionAccountingScoring(models.AbstractModel):
+    _name = 'fusion.accounting.scoring'
+    _description = 'Fusion Accounting Confidence Scoring'
+
+    def calculate_confidence(self, tool_name, scenario_key=None):
+        domain = [('tool_name', '=', tool_name)]
+        if scenario_key:
+            domain.append(('tool_params', 'ilike', scenario_key))
+        history = self.env['fusion.accounting.match.history'].search(domain)
+        if not history:
+            return 0.0
+        decided = history.filtered(lambda h: h.decision in ('approved', 'rejected'))
+        if not decided:
+            return 0.0
+        approved = len(decided.filtered(lambda h: h.decision == 'approved'))
+        return approved / len(decided)
+
+    def check_promotions(self):
+        ICP = self.env['ir.config_parameter'].sudo()
+        threshold = float(ICP.get_param('fusion_accounting.tier3_threshold', '0.95'))
+        min_sample = int(ICP.get_param('fusion_accounting.tier3_min_sample', '30'))
+
+        rules = self.env['fusion.accounting.rule'].search([
+            ('active', '=', True),
+            ('approval_tier', '=', 'needs_approval'),
+        ])
+        promoted = self.env['fusion.accounting.rule']
+        for rule in rules:
+            if rule.total_uses >= min_sample and rule.confidence_score >= threshold:
+                rule.approval_tier = 'auto'
+                promoted |= rule
+                _logger.info(
+                    "Promoted rule '%s' to auto (confidence=%.2f, sample=%d)",
+                    rule.name, rule.confidence_score, rule.total_uses,
+                )
+        return promoted
+
+    def get_tool_stats(self, tool_name=None):
+        domain = []
+        if tool_name:
+            domain.append(('tool_name', '=', tool_name))
+        history = self.env['fusion.accounting.match.history'].search(domain)
+
+        stats = {}
+        for h in history:
+            if h.tool_name not in stats:
+                stats[h.tool_name] = {
+                    'total': 0, 'approved': 0, 'rejected': 0,
+                    'pending': 0, 'auto': 0,
+                }
+            stats[h.tool_name]['total'] += 1
+            if h.decision in stats[h.tool_name]:
+                stats[h.tool_name][h.decision] += 1
+        return stats

fusion_accounting/services/tools/__init__.py

@@ -0,0 +1,19 @@
+from .bank_reconciliation import TOOLS as BANK_RECON_TOOLS
+from .hst_management import TOOLS as HST_TOOLS
+from .accounts_receivable import TOOLS as AR_TOOLS
+from .accounts_payable import TOOLS as AP_TOOLS
+from .journal_review import TOOLS as JOURNAL_TOOLS
+from .month_end import TOOLS as MONTH_END_TOOLS
+from .payroll import TOOLS as PAYROLL_TOOLS
+from .inventory import TOOLS as INVENTORY_TOOLS
+from .adp import TOOLS as ADP_TOOLS
+from .reporting import TOOLS as REPORTING_TOOLS
+from .audit import TOOLS as AUDIT_TOOLS
+
+TOOL_DISPATCH = {}
+for tools_dict in [
+    BANK_RECON_TOOLS, HST_TOOLS, AR_TOOLS, AP_TOOLS, JOURNAL_TOOLS,
+    MONTH_END_TOOLS, PAYROLL_TOOLS, INVENTORY_TOOLS, ADP_TOOLS,
+    REPORTING_TOOLS, AUDIT_TOOLS,
+]:
+    TOOL_DISPATCH.update(tools_dict)

fusion_accounting/services/tools/accounts_payable.py

@@ -0,0 +1,150 @@
+import logging
+from odoo import fields
+from datetime import timedelta
+
+_logger = logging.getLogger(__name__)
+
+
+def get_ap_aging(env, params):
+    today = fields.Date.today()
+    domain = [
+        ('account_id.account_type', '=', 'liability_payable'),
+        ('parent_state', '=', 'posted'),
+        ('reconciled', '=', False),
+        ('company_id', '=', env.company.id),
+    ]
+    amls = env['account.move.line'].search(domain)
+
+    buckets = {'current': 0, '1_30': 0, '31_60': 0, '61_90': 0, '90_plus': 0}
+    for aml in amls:
+        amt = abs(aml.amount_residual)
+        if not aml.date_maturity or aml.date_maturity >= today:
+            buckets['current'] += amt
+        else:
+            days = (today - aml.date_maturity).days
+            if days <= 30:
+                buckets['1_30'] += amt
+            elif days <= 60:
+                buckets['31_60'] += amt
+            elif days <= 90:
+                buckets['61_90'] += amt
+            else:
+                buckets['90_plus'] += amt
+
+    return {'total': sum(buckets.values()), 'buckets': buckets, 'line_count': len(amls)}
+
+
+def find_duplicate_bills(env, params):
+    window_days = int(params.get('window_days', 7))
+    bills = env['account.move'].search([
+        ('move_type', 'in', ('in_invoice', 'in_refund')),
+        ('state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ], order='partner_id, amount_total, date')
+
+    duplicates = []
+    prev = None
+    for bill in bills:
+        if prev and (
+            prev.partner_id == bill.partner_id
+            and abs(prev.amount_total - bill.amount_total) < 0.01
+            and abs((prev.date - bill.date).days) <= window_days
+        ):
+            duplicates.append({
+                'bill_1': {'id': prev.id, 'name': prev.name, 'date': str(prev.date)},
+                'bill_2': {'id': bill.id, 'name': bill.name, 'date': str(bill.date)},
+                'partner': bill.partner_id.name,
+                'amount': bill.amount_total,
+            })
+        prev = bill
+
+    return {'count': len(duplicates), 'duplicates': duplicates[:20]}
+
+
+def match_bill_to_po(env, params):
+    bill_id = int(params['bill_id'])
+    bill = env['account.move'].browse(bill_id)
+    if not bill.exists():
+        return {'error': 'Bill not found'}
+    matches = []
+    for line in bill.invoice_line_ids:
+        if line.purchase_line_id:
+            matches.append({
+                'bill_line': line.name or '',
+                'po': line.purchase_line_id.order_id.name,
+                'po_line': line.purchase_line_id.name,
+                'po_qty': line.purchase_line_id.product_qty,
+                'bill_qty': line.quantity,
+                'match': abs(line.quantity - line.purchase_line_id.product_qty) < 0.01,
+            })
+    return {'bill': bill.name, 'matches': matches, 'unmatched_lines': len(bill.invoice_line_ids) - len(matches)}
+
+
+def get_unpaid_bills(env, params):
+    domain = [
+        ('move_type', 'in', ('in_invoice', 'in_refund')),
+        ('state', '=', 'posted'),
+        ('payment_state', 'in', ('not_paid', 'partial')),
+        ('company_id', '=', env.company.id),
+    ]
+    if params.get('partner_id'):
+        domain.append(('partner_id', '=', int(params['partner_id'])))
+    bills = env['account.move'].search(domain, order='invoice_date_due asc', limit=int(params.get('limit', 50)))
+    return {
+        'count': len(bills),
+        'total': sum(b.amount_residual for b in bills),
+        'bills': [{
+            'id': b.id, 'name': b.name,
+            'partner': b.partner_id.name if b.partner_id else '',
+            'amount_total': b.amount_total,
+            'amount_residual': b.amount_residual,
+            'date_due': str(b.invoice_date_due) if b.invoice_date_due else '',
+        } for b in bills],
+    }
+
+
+def verify_bill_taxes(env, params):
+    bill_id = int(params['bill_id'])
+    bill = env['account.move'].browse(bill_id)
+    if not bill.exists():
+        return {'error': 'Bill not found'}
+    issues = []
+    for line in bill.invoice_line_ids:
+        if line.product_id and not line.tax_ids:
+            issues.append({
+                'line': line.name or line.product_id.name,
+                'issue': 'No tax applied to product line',
+            })
+    return {'bill': bill.name, 'issues': issues, 'clean': len(issues) == 0}
+
+
+def get_payment_schedule(env, params):
+    days_ahead = int(params.get('days_ahead', 30))
+    cutoff = fields.Date.today() + timedelta(days=days_ahead)
+    bills = env['account.move'].search([
+        ('move_type', '=', 'in_invoice'),
+        ('state', '=', 'posted'),
+        ('payment_state', 'in', ('not_paid', 'partial')),
+        ('invoice_date_due', '<=', cutoff),
+        ('company_id', '=', env.company.id),
+    ], order='invoice_date_due asc')
+    return {
+        'period': f'Next {days_ahead} days',
+        'total': sum(b.amount_residual for b in bills),
+        'bills': [{
+            'id': b.id, 'name': b.name,
+            'partner': b.partner_id.name if b.partner_id else '',
+            'amount_residual': b.amount_residual,
+            'date_due': str(b.invoice_date_due) if b.invoice_date_due else '',
+        } for b in bills[:50]],
+    }
+
+
+TOOLS = {
+    'get_ap_aging': get_ap_aging,
+    'find_duplicate_bills': find_duplicate_bills,
+    'match_bill_to_po': match_bill_to_po,
+    'get_unpaid_bills': get_unpaid_bills,
+    'verify_bill_taxes': verify_bill_taxes,
+    'get_payment_schedule': get_payment_schedule,
+}

fusion_accounting/services/tools/accounts_receivable.py

@@ -0,0 +1,165 @@
+import logging
+from odoo import fields
+
+_logger = logging.getLogger(__name__)
+
+
+def get_ar_aging(env, params):
+    today = fields.Date.today()
+    domain = [
+        ('account_id.account_type', '=', 'asset_receivable'),
+        ('parent_state', '=', 'posted'),
+        ('reconciled', '=', False),
+        ('company_id', '=', env.company.id),
+    ]
+    amls = env['account.move.line'].search(domain)
+
+    buckets = {'current': 0, '1_30': 0, '31_60': 0, '61_90': 0, '90_plus': 0}
+    for aml in amls:
+        if not aml.date_maturity or aml.date_maturity >= today:
+            buckets['current'] += aml.amount_residual
+        else:
+            days = (today - aml.date_maturity).days
+            if days <= 30:
+                buckets['1_30'] += aml.amount_residual
+            elif days <= 60:
+                buckets['31_60'] += aml.amount_residual
+            elif days <= 90:
+                buckets['61_90'] += aml.amount_residual
+            else:
+                buckets['90_plus'] += aml.amount_residual
+
+    return {
+        'total': sum(buckets.values()),
+        'buckets': buckets,
+        'line_count': len(amls),
+    }
+
+
+def get_overdue_invoices(env, params):
+    today = fields.Date.today()
+    days_overdue = int(params.get('min_days_overdue', 1))
+    from datetime import timedelta
+    cutoff = today - timedelta(days=days_overdue)
+    invoices = env['account.move'].search([
+        ('move_type', '=', 'out_invoice'),
+        ('state', '=', 'posted'),
+        ('payment_state', 'in', ('not_paid', 'partial')),
+        ('invoice_date_due', '<', cutoff),
+        ('company_id', '=', env.company.id),
+    ], order='invoice_date_due asc', limit=int(params.get('limit', 50)))
+    return {
+        'count': len(invoices),
+        'invoices': [{
+            'id': inv.id,
+            'name': inv.name,
+            'partner': inv.partner_id.name if inv.partner_id else '',
+            'email': inv.partner_id.email or '' if inv.partner_id else '',
+            'phone': inv.partner_id.phone or '' if inv.partner_id else '',
+            'amount_total': inv.amount_total,
+            'amount_residual': inv.amount_residual,
+            'date_due': str(inv.invoice_date_due),
+            'days_overdue': (today - inv.invoice_date_due).days,
+        } for inv in invoices],
+    }
+
+
+def get_partner_balance(env, params):
+    partner_id = int(params['partner_id'])
+    partner = env['res.partner'].browse(partner_id)
+    if not partner.exists():
+        return {'error': 'Partner not found'}
+    amls = env['account.move.line'].search([
+        ('partner_id', '=', partner_id),
+        ('account_id.account_type', '=', 'asset_receivable'),
+        ('parent_state', '=', 'posted'),
+        ('reconciled', '=', False),
+        ('company_id', '=', env.company.id),
+    ])
+    return {
+        'partner': partner.name,
+        'balance': sum(aml.amount_residual for aml in amls),
+        'open_items': [{
+            'id': aml.id,
+            'ref': aml.ref or aml.move_id.name,
+            'date': str(aml.date),
+            'amount_residual': aml.amount_residual,
+            'date_maturity': str(aml.date_maturity) if aml.date_maturity else '',
+        } for aml in amls],
+    }
+
+
+def send_followup(env, params):
+    partner_id = int(params['partner_id'])
+    partner = env['res.partner'].browse(partner_id)
+    if not partner.exists():
+        return {'error': 'Partner not found'}
+    options = {
+        'partner_id': partner_id,
+        'email': params.get('send_email', False),
+        'print': params.get('print_letter', False),
+        'sms': False,
+    }
+    if params.get('email_subject'):
+        options['email_subject'] = params['email_subject']
+    if params.get('body'):
+        options['body'] = params['body']
+    result = partner.execute_followup(options)
+    return {'status': 'sent', 'partner': partner.name, 'result': str(result) if result else 'done'}
+
+
+def get_followup_report(env, params):
+    partner_id = int(params['partner_id'])
+    partner = env['res.partner'].browse(partner_id)
+    if not partner.exists():
+        return {'error': 'Partner not found'}
+    try:
+        report = env['account.followup.report']
+        html = report._get_followup_report_html(partner)
+        return {'partner': partner.name, 'html': html}
+    except Exception as e:
+        return {'error': str(e)}
+
+
+def reconcile_payment_to_invoice(env, params):
+    move_line_ids = [int(x) for x in params['move_line_ids']]
+    amls = env['account.move.line'].browse(move_line_ids)
+    if len(amls) < 2:
+        return {'error': 'Need at least 2 journal items to reconcile'}
+    amls.reconcile()
+    return {
+        'status': 'reconciled',
+        'move_line_ids': move_line_ids,
+    }
+
+
+def get_unmatched_payments(env, params):
+    domain = [
+        ('account_id.account_type', '=', 'asset_receivable'),
+        ('parent_state', '=', 'posted'),
+        ('reconciled', '=', False),
+        ('move_id.payment_id', '!=', False),
+        ('company_id', '=', env.company.id),
+    ]
+    amls = env['account.move.line'].search(domain, order='date desc')
+    return {
+        'count': len(amls),
+        'payments': [{
+            'id': aml.id,
+            'date': str(aml.date),
+            'ref': aml.ref or aml.move_id.name,
+            'partner': aml.partner_id.name if aml.partner_id else '',
+            'amount': abs(aml.amount_residual),
+        } for aml in amls[:50]],
+    }
+
+
+TOOLS = {
+    'get_ar_aging': get_ar_aging,
+    'get_overdue_invoices': get_overdue_invoices,
+    'get_partner_balance': get_partner_balance,
+    'send_followup': send_followup,
+    'get_followup_report': get_followup_report,
+    'reconcile_payment_to_invoice': reconcile_payment_to_invoice,
+    'get_unmatched_payments': get_unmatched_payments,
+}

fusion_accounting/services/tools/adp.py

@@ -0,0 +1,111 @@
+import logging
+from odoo import fields
+
+_logger = logging.getLogger(__name__)
+
+
+def get_adp_receivable_aging(env, params):
+    accounts = env['account.account'].search([
+        ('code', '=like', '1101%'),
+        ('company_id', '=', env.company.id),
+    ])
+    today = fields.Date.today()
+    amls = env['account.move.line'].search([
+        ('account_id', 'in', accounts.ids),
+        ('reconciled', '=', False),
+        ('parent_state', '=', 'posted'),
+    ])
+    buckets = {'current': 0, '1_30': 0, '31_60': 0, '61_90': 0, '90_plus': 0}
+    for aml in amls:
+        amt = abs(aml.amount_residual)
+        if not aml.date_maturity or aml.date_maturity >= today:
+            buckets['current'] += amt
+        else:
+            days = (today - aml.date_maturity).days
+            if days <= 30:
+                buckets['1_30'] += amt
+            elif days <= 60:
+                buckets['31_60'] += amt
+            elif days <= 90:
+                buckets['61_90'] += amt
+            else:
+                buckets['90_plus'] += amt
+    return {'total': sum(buckets.values()), 'buckets': buckets}
+
+
+def match_adp_payment_to_invoice(env, params):
+    move_line_ids = [int(x) for x in params['move_line_ids']]
+    amls = env['account.move.line'].browse(move_line_ids).exists()
+    if len(amls) < 2:
+        return {'error': 'Need at least 2 existing journal items to reconcile'}
+    amls.reconcile()
+    return {'status': 'matched', 'move_line_ids': amls.ids}
+
+
+def verify_adp_split(env, params):
+    invoice_id = int(params['invoice_id'])
+    invoice = env['account.move'].browse(invoice_id)
+    if not invoice.exists():
+        return {'error': 'Invoice not found'}
+    lines = invoice.invoice_line_ids
+    total = invoice.amount_untaxed
+    return {
+        'invoice': invoice.name,
+        'total_untaxed': total,
+        'total_with_tax': invoice.amount_total,
+        'lines': [{'name': l.name, 'subtotal': l.price_subtotal, 'total': l.price_total} for l in lines],
+        'balanced': abs(sum(l.price_subtotal for l in lines) - total) < 0.01,
+    }
+
+
+def find_adp_without_payment(env, params):
+    adp_partner = env['res.partner'].search([('name', 'ilike', 'ADP')], limit=1)
+    if not adp_partner:
+        return {'status': 'info', 'message': 'No ADP partner found in the system.'}
+    invoices = env['account.move'].search([
+        ('partner_id', '=', adp_partner.id),
+        ('move_type', '=', 'out_invoice'),
+        ('state', '=', 'posted'),
+        ('payment_state', 'in', ('not_paid', 'partial')),
+    ])
+    return {
+        'count': len(invoices),
+        'invoices': [{
+            'id': inv.id, 'name': inv.name,
+            'amount': inv.amount_residual, 'date': str(inv.date),
+        } for inv in invoices[:20]],
+    }
+
+
+def get_adp_summary(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    accounts = env['account.account'].search([
+        ('code', '=like', '1101%'), ('company_id', '=', env.company.id),
+    ])
+    domain = [
+        ('account_id', 'in', accounts.ids),
+        ('parent_state', '=', 'posted'),
+    ]
+    if date_from:
+        domain.append(('date', '>=', date_from))
+    if date_to:
+        domain.append(('date', '<=', date_to))
+    lines = env['account.move.line'].search(domain)
+    total_debit = sum(l.debit for l in lines)
+    total_credit = sum(l.credit for l in lines)
+    return {
+        'period': f'{date_from or "all"} to {date_to or "now"}',
+        'billed': total_debit,
+        'collected': total_credit,
+        'outstanding': total_debit - total_credit,
+    }
+
+
+TOOLS = {
+    'get_adp_receivable_aging': get_adp_receivable_aging,
+    'match_adp_payment_to_invoice': match_adp_payment_to_invoice,
+    'verify_adp_split': verify_adp_split,
+    'find_adp_without_payment': find_adp_without_payment,
+    'get_adp_summary': get_adp_summary,
+}

fusion_accounting/services/tools/audit.py

@@ -0,0 +1,156 @@
+import logging
+from odoo import fields
+
+_logger = logging.getLogger(__name__)
+
+
+def audit_posted_entry(env, params):
+    move_id = int(params['move_id'])
+    move = env['account.move'].browse(move_id)
+    if not move.exists():
+        return {'error': 'Entry not found'}
+    issues = []
+    total_debit = sum(l.debit for l in move.line_ids)
+    total_credit = sum(l.credit for l in move.line_ids)
+    if abs(total_debit - total_credit) > 0.01:
+        issues.append({'severity': 'critical', 'issue': f'Unbalanced entry: debit={total_debit}, credit={total_credit}'})
+    for line in move.line_ids:
+        if not line.account_id:
+            issues.append({'severity': 'critical', 'issue': f'Line missing account: {line.name}'})
+    if not move.line_ids:
+        issues.append({'severity': 'warning', 'issue': 'Entry has no lines'})
+    return {
+        'move': move.name, 'date': str(move.date),
+        'issues': issues, 'clean': len(issues) == 0,
+    }
+
+
+def audit_account_balances(env, params):
+    from .journal_review import find_wrong_direction_balances
+    return find_wrong_direction_balances(env, params)
+
+
+def audit_tax_compliance(env, params):
+    from .hst_management import find_missing_tax_invoices, find_missing_itc_bills
+    invoices = find_missing_tax_invoices(env, params)
+    bills = find_missing_itc_bills(env, params)
+    return {
+        'missing_tax_invoices': invoices.get('missing_tax_count', 0),
+        'missing_itc_bills': bills.get('missing_itc_count', 0),
+        'total_issues': invoices.get('missing_tax_count', 0) + bills.get('missing_itc_count', 0),
+    }
+
+
+def audit_reconciliation_integrity(env, params):
+    from .journal_review import verify_reconciliation_integrity
+    return verify_reconciliation_integrity(env, params)
+
+
+def check_hash_chain(env, params):
+    from .month_end import run_hash_integrity_check
+    return run_hash_integrity_check(env, params)
+
+
+def check_sequence_gaps(env, params):
+    from .journal_review import find_sequence_gaps
+    return find_sequence_gaps(env, params)
+
+
+def flag_entry(env, params):
+    move_id = int(params['move_id'])
+    flag = params.get('flag', 'Review Required')
+    recommendation = params.get('recommendation', '')
+    move = env['account.move'].browse(move_id)
+    if not move.exists():
+        return {'error': 'Entry not found'}
+    body = f'<strong>🏴 {flag}</strong><br/>{recommendation}'
+    move.message_post(body=body, message_type='comment', subtype_xmlid='mail.mt_note')
+    return {'status': 'flagged', 'move': move.name, 'flag': flag}
+
+
+def get_audit_status(env, params):
+    statuses = env['account.audit.account.status'].search([])
+    return {
+        'statuses': [{
+            'id': s.id,
+            'account': s.account_id.name,
+            'status': s.status,
+            'audit': s.audit_id.display_name if s.audit_id else '',
+        } for s in statuses[:50]],
+    }
+
+
+def set_audit_status(env, params):
+    status_id = int(params['status_id'])
+    new_status = params['status']
+    rec = env['account.audit.account.status'].browse(status_id)
+    if not rec.exists():
+        return {'error': 'Audit status record not found'}
+    rec.status = new_status
+    return {'status': 'updated', 'id': status_id, 'new_status': new_status}
+
+
+def get_audit_trail(env, params):
+    move_id = int(params['move_id'])
+    move = env['account.move'].browse(move_id)
+    if not move.exists():
+        return {'error': 'Entry not found'}
+    messages = env['mail.message'].search([
+        ('model', '=', 'account.move'),
+        ('res_id', '=', move_id),
+    ], order='date desc', limit=20)
+    return {
+        'move': move.name,
+        'messages': [{
+            'date': str(m.date),
+            'author': m.author_id.name if m.author_id else '',
+            'body': m.body or '',
+            'type': m.message_type,
+        } for m in messages],
+    }
+
+
+def run_full_audit(env, params):
+    results = {}
+    results['account_balances'] = audit_account_balances(env, params)
+    results['tax_compliance'] = audit_tax_compliance(env, params)
+    results['reconciliation'] = audit_reconciliation_integrity(env, params)
+    results['hash_chain'] = check_hash_chain(env, params)
+    results['sequence_gaps'] = check_sequence_gaps(env, params)
+
+    total_issues = 0
+    for key, val in results.items():
+        total_issues += val.get('count', 0) + val.get('total_issues', 0)
+
+    score = max(0, 100 - total_issues * 5)
+    return {
+        'score': min(100, score),
+        'total_issues': total_issues,
+        'details': results,
+    }
+
+
+def get_audit_report(env, params):
+    audit = run_full_audit(env, params)
+    report_lines = [f"Audit Score: {audit['score']}/100", f"Total Issues: {audit['total_issues']}", '']
+    for domain, detail in audit.get('details', {}).items():
+        report_lines.append(f"--- {domain.replace('_', ' ').title()} ---")
+        count = detail.get('count', detail.get('total_issues', 0))
+        report_lines.append(f"  Issues: {count}")
+    return {'report': '\n'.join(report_lines), 'score': audit['score']}
+
+
+TOOLS = {
+    'audit_posted_entry': audit_posted_entry,
+    'audit_account_balances': audit_account_balances,
+    'audit_tax_compliance': audit_tax_compliance,
+    'audit_reconciliation_integrity': audit_reconciliation_integrity,
+    'check_hash_chain': check_hash_chain,
+    'check_sequence_gaps': check_sequence_gaps,
+    'flag_entry': flag_entry,
+    'get_audit_status': get_audit_status,
+    'set_audit_status': set_audit_status,
+    'get_audit_trail': get_audit_trail,
+    'run_full_audit': run_full_audit,
+    'get_audit_report': get_audit_report,
+}

fusion_accounting/services/tools/bank_reconciliation.py

@@ -0,0 +1,177 @@
+import logging
+from datetime import datetime
+
+_logger = logging.getLogger(__name__)
+
+
+def get_unreconciled_bank_lines(env, params):
+    domain = [('is_reconciled', '=', False), ('company_id', '=', env.company.id)]
+    if params.get('journal_id'):
+        domain.append(('journal_id', '=', int(params['journal_id'])))
+    if params.get('date_from'):
+        domain.append(('date', '>=', params['date_from']))
+    if params.get('date_to'):
+        domain.append(('date', '<=', params['date_to']))
+    if params.get('min_amount'):
+        domain.append(('amount', '>=', float(params['min_amount'])))
+    limit = int(params.get('limit', 50))
+    lines = env['account.bank.statement.line'].search(domain, limit=limit, order='date desc')
+    return {
+        'count': len(lines),
+        'total_amount': sum(abs(l.amount) for l in lines),
+        'lines': [{
+            'id': l.id,
+            'date': str(l.date),
+            'payment_ref': l.payment_ref or '',
+            'partner_name': l.partner_name or (l.partner_id.name if l.partner_id else ''),
+            'amount': l.amount,
+            'journal': l.journal_id.name,
+        } for l in lines],
+    }
+
+
+def get_unreconciled_receipts(env, params):
+    account_code = params.get('account_code', '1122')
+    accounts = env['account.account'].search([
+        ('code', '=like', f'{account_code}%'),
+        ('company_id', '=', env.company.id),
+    ])
+    domain = [
+        ('account_id', 'in', accounts.ids),
+        ('reconciled', '=', False),
+        ('parent_state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    lines = env['account.move.line'].search(domain, order='date desc')
+    return {
+        'count': len(lines),
+        'total_amount': sum(abs(l.amount_residual) for l in lines),
+        'lines': [{
+            'id': l.id,
+            'date': str(l.date),
+            'ref': l.ref or l.move_id.name,
+            'partner': l.partner_id.name if l.partner_id else '',
+            'amount_residual': l.amount_residual,
+        } for l in lines],
+    }
+
+
+def match_bank_line_to_payments(env, params):
+    st_line_id = int(params['statement_line_id'])
+    move_line_ids = [int(x) for x in params['move_line_ids']]
+    st_line = env['account.bank.statement.line'].browse(st_line_id)
+    if not st_line.exists():
+        return {'error': 'Statement line not found'}
+    st_line.set_line_bank_statement_line(move_line_ids)
+    return {
+        'status': 'matched',
+        'statement_line_id': st_line_id,
+        'matched_move_lines': move_line_ids,
+        'is_reconciled': st_line.is_reconciled,
+    }
+
+
+def auto_reconcile_bank_lines(env, params):
+    company_id = params.get('company_id', env.company.id)
+    lines = env['account.bank.statement.line'].search([
+        ('is_reconciled', '=', False),
+        ('company_id', '=', int(company_id)),
+    ])
+    before_count = len(lines)
+    lines._try_auto_reconcile_statement_lines(company_id=int(company_id))
+    still_unreconciled = env['account.bank.statement.line'].search([
+        ('is_reconciled', '=', False),
+        ('company_id', '=', int(company_id)),
+    ])
+    reconciled_count = before_count - len(still_unreconciled)
+    return {
+        'status': 'completed',
+        'lines_before': before_count,
+        'lines_reconciled': reconciled_count,
+        'lines_remaining': len(still_unreconciled),
+    }
+
+
+def apply_reconcile_model(env, params):
+    model_id = int(params['model_id'])
+    st_line_id = int(params['statement_line_id'])
+    reco_model = env['account.reconcile.model'].browse(model_id)
+    st_line = env['account.bank.statement.line'].browse(st_line_id)
+    if not reco_model.exists() or not st_line.exists():
+        return {'error': 'Model or statement line not found'}
+    _liquidity_lines, suspense_lines, _other_lines = st_line._seek_for_lines()
+    residual = sum(l.amount_residual for l in suspense_lines) if suspense_lines else st_line.amount
+    write_off_vals = reco_model._get_write_off_move_lines_dict(st_line, residual)
+    if write_off_vals:
+        line_ids_create_command = [(0, 0, vals) for vals in write_off_vals]
+        st_line.move_id.write({'line_ids': line_ids_create_command})
+    return {
+        'status': 'applied',
+        'model': reco_model.name,
+        'write_off_lines': len(write_off_vals) if write_off_vals else 0,
+    }
+
+
+def unmatch_bank_line(env, params):
+    st_line_id = int(params['statement_line_id'])
+    st_line = env['account.bank.statement.line'].browse(st_line_id)
+    if not st_line.exists():
+        return {'error': 'Statement line not found'}
+    st_line.action_unreconcile_entry()
+    return {'status': 'unmatched', 'statement_line_id': st_line_id}
+
+
+def get_reconcile_suggestions(env, params):
+    st_line_id = int(params['statement_line_id'])
+    st_line = env['account.bank.statement.line'].browse(st_line_id)
+    if not st_line.exists():
+        return {'error': 'Statement line not found'}
+    models = env['account.reconcile.model'].search([
+        ('company_id', '=', env.company.id),
+    ])
+    return {
+        'models': [{
+            'id': m.id,
+            'name': m.name,
+            'trigger': m.trigger if hasattr(m, 'trigger') else 'manual',
+        } for m in models],
+    }
+
+
+def sum_payments_by_date(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    if not date_from or not date_to:
+        return {'error': 'date_from and date_to are required'}
+    journal_ids = params.get('journal_ids', [])
+    domain = [
+        ('parent_state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+        ('date', '>=', date_from),
+        ('date', '<=', date_to),
+    ]
+    if journal_ids:
+        domain.append(('journal_id', 'in', [int(j) for j in journal_ids]))
+    lines = env['account.move.line'].search(domain)
+    total_debit = sum(l.debit for l in lines)
+    total_credit = sum(l.credit for l in lines)
+    return {
+        'date_from': date_from,
+        'date_to': date_to,
+        'total_debit': total_debit,
+        'total_credit': total_credit,
+        'net': total_debit - total_credit,
+        'line_count': len(lines),
+    }
+
+
+TOOLS = {
+    'get_unreconciled_bank_lines': get_unreconciled_bank_lines,
+    'get_unreconciled_receipts': get_unreconciled_receipts,
+    'match_bank_line_to_payments': match_bank_line_to_payments,
+    'auto_reconcile_bank_lines': auto_reconcile_bank_lines,
+    'apply_reconcile_model': apply_reconcile_model,
+    'unmatch_bank_line': unmatch_bank_line,
+    'get_reconcile_suggestions': get_reconcile_suggestions,
+    'sum_payments_by_date': sum_payments_by_date,
+}

fusion_accounting/services/tools/hst_management.py

@@ -0,0 +1,171 @@
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+def calculate_hst_balance(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    base_domain = [
+        ('parent_state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if date_from:
+        base_domain.append(('date', '>=', date_from))
+    if date_to:
+        base_domain.append(('date', '<=', date_to))
+
+    collected_accounts = env['account.account'].search([
+        ('code', '=like', '2005%'), ('company_id', '=', env.company.id),
+    ])
+    itc_accounts = env['account.account'].search([
+        ('code', '=like', '2006%'), ('company_id', '=', env.company.id),
+    ])
+
+    collected_lines = env['account.move.line'].search(
+        base_domain + [('account_id', 'in', collected_accounts.ids)]
+    )
+    itc_lines = env['account.move.line'].search(
+        base_domain + [('account_id', 'in', itc_accounts.ids)]
+    )
+
+    hst_collected = abs(sum(l.balance for l in collected_lines))
+    itcs = abs(sum(l.balance for l in itc_lines))
+
+    return {
+        'hst_collected': hst_collected,
+        'input_tax_credits': itcs,
+        'net_hst': hst_collected - itcs,
+        'status': 'owing' if (hst_collected - itcs) > 0 else 'refund',
+        'period': f'{date_from or "all"} to {date_to or "now"}',
+    }
+
+
+def get_tax_report(env, params):
+    report_ref = params.get('report_ref', 'account.generic_tax_report')
+    try:
+        report = env.ref(report_ref)
+    except Exception:
+        return {'error': f'Report not found: {report_ref}'}
+    options = report.get_options({
+        'date': {
+            'date_from': params.get('date_from', ''),
+            'date_to': params.get('date_to', ''),
+        }
+    })
+    lines = report._get_lines(options)
+    return {
+        'report_name': report.name,
+        'lines': [{
+            'name': l.get('name', ''),
+            'columns': [c.get('no_format', c.get('name', '')) for c in l.get('columns', [])],
+        } for l in lines[:50]],
+    }
+
+
+def find_missing_tax_invoices(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    domain = [
+        ('move_type', 'in', ('out_invoice', 'out_refund')),
+        ('state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if date_from:
+        domain.append(('date', '>=', date_from))
+    if date_to:
+        domain.append(('date', '<=', date_to))
+
+    invoices = env['account.move'].search(domain)
+    missing = invoices.filtered(
+        lambda inv: not any(line.tax_ids for line in inv.invoice_line_ids)
+    )
+    return {
+        'total_invoices': len(invoices),
+        'missing_tax_count': len(missing),
+        'invoices': [{
+            'id': inv.id,
+            'name': inv.name,
+            'partner': inv.partner_id.name if inv.partner_id else '',
+            'amount_total': inv.amount_total,
+            'date': str(inv.date),
+        } for inv in missing[:30]],
+    }
+
+
+def find_missing_itc_bills(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    domain = [
+        ('move_type', 'in', ('in_invoice', 'in_refund')),
+        ('state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if date_from:
+        domain.append(('date', '>=', date_from))
+    if date_to:
+        domain.append(('date', '<=', date_to))
+
+    bills = env['account.move'].search(domain)
+    missing = bills.filtered(
+        lambda b: not any(line.tax_ids for line in b.invoice_line_ids)
+    )
+    return {
+        'total_bills': len(bills),
+        'missing_itc_count': len(missing),
+        'bills': [{
+            'id': b.id,
+            'name': b.name,
+            'partner': b.partner_id.name if b.partner_id else '',
+            'amount_total': b.amount_total,
+            'date': str(b.date),
+        } for b in missing[:30]],
+    }
+
+
+def get_tax_return_status(env, params):
+    returns = env['account.return'].search([
+        ('company_id', '=', env.company.id),
+    ], order='date_start desc', limit=10)
+    return {
+        'returns': [{
+            'id': r.id,
+            'name': r.display_name,
+            'date_start': str(r.date_start) if hasattr(r, 'date_start') else '',
+            'date_end': str(r.date_end) if hasattr(r, 'date_end') else '',
+            'state': r.state if hasattr(r, 'state') else '',
+        } for r in returns],
+    }
+
+
+def generate_tax_return(env, params):
+    try:
+        env['account.return']._generate_or_refresh_all_returns(
+            company=env.company
+        )
+        return {'status': 'generated', 'message': 'Tax returns refreshed successfully.'}
+    except Exception as e:
+        return {'error': str(e)}
+
+
+def validate_tax_return(env, params):
+    return_id = int(params['return_id'])
+    tax_return = env['account.return'].browse(return_id)
+    if not tax_return.exists():
+        return {'error': 'Tax return not found'}
+    try:
+        tax_return.action_validate()
+        return {'status': 'validated', 'return_id': return_id}
+    except Exception as e:
+        return {'error': str(e)}
+
+
+TOOLS = {
+    'calculate_hst_balance': calculate_hst_balance,
+    'get_tax_report': get_tax_report,
+    'find_missing_tax_invoices': find_missing_tax_invoices,
+    'find_missing_itc_bills': find_missing_itc_bills,
+    'get_tax_return_status': get_tax_return_status,
+    'generate_tax_return': generate_tax_return,
+    'validate_tax_return': validate_tax_return,
+}

fusion_accounting/services/tools/inventory.py

@@ -0,0 +1,113 @@
+import logging
+from odoo import fields
+
+_logger = logging.getLogger(__name__)
+
+
+def get_stock_valuation(env, params):
+    accounts = env['account.account'].search([
+        ('code', '=like', '1069%'),
+        ('company_id', '=', env.company.id),
+    ])
+    result = []
+    for acct in accounts:
+        balance = sum(env['account.move.line'].search([
+            ('account_id', '=', acct.id),
+            ('parent_state', '=', 'posted'),
+        ]).mapped('balance'))
+        result.append({'code': acct.code, 'name': acct.name, 'balance': balance})
+    return {'accounts': result, 'total': sum(r['balance'] for r in result)}
+
+
+def get_price_differences(env, params):
+    accounts = env['account.account'].search([
+        ('code', '=like', '5010%'),
+        ('company_id', '=', env.company.id),
+    ])
+    domain = [
+        ('account_id', 'in', accounts.ids),
+        ('parent_state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if params.get('date_from'):
+        domain.append(('date', '>=', params['date_from']))
+    if params.get('date_to'):
+        domain.append(('date', '<=', params['date_to']))
+    lines = env['account.move.line'].search(domain, order='date desc', limit=50)
+    return {
+        'total': sum(l.balance for l in lines),
+        'entries': [{
+            'id': l.id, 'date': str(l.date),
+            'move': l.move_id.name, 'amount': l.balance,
+            'partner': l.partner_id.name if l.partner_id else '',
+        } for l in lines],
+    }
+
+
+def get_cogs_ratio_by_category(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    base_domain = [
+        ('parent_state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if date_from:
+        base_domain.append(('date', '>=', date_from))
+    if date_to:
+        base_domain.append(('date', '<=', date_to))
+
+    revenue_lines = env['account.move.line'].search(
+        base_domain + [('account_id.account_type', '=', 'income')]
+    )
+    cogs_lines = env['account.move.line'].search(
+        base_domain + [('account_id.account_type', '=', 'expense_direct_cost')]
+    )
+    revenue = abs(sum(l.balance for l in revenue_lines))
+    cogs = abs(sum(l.balance for l in cogs_lines))
+    ratio = (cogs / revenue * 100) if revenue else 0
+    return {'revenue': revenue, 'cogs': cogs, 'ratio_pct': round(ratio, 2)}
+
+
+def find_unusual_adjustments(env, params):
+    threshold = float(params.get('threshold', 1000))
+    domain = [
+        ('parent_state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+        ('account_id.account_type', '=', 'expense_direct_cost'),
+    ]
+    lines = env['account.move.line'].search(domain)
+    unusual = lines.filtered(lambda l: abs(l.balance) > threshold)
+    return {
+        'count': len(unusual),
+        'adjustments': [{
+            'id': l.id, 'date': str(l.date), 'move': l.move_id.name,
+            'amount': l.balance, 'name': l.name or '',
+        } for l in unusual[:20]],
+    }
+
+
+def get_inventory_turnover(env, params):
+    from .reporting import get_profit_loss
+    pl = get_profit_loss(env, params)
+    stock = get_stock_valuation(env, params)
+    avg_inventory = stock.get('total', 0)
+    cogs = 0
+    for line in pl.get('lines', []):
+        if 'cost' in line.get('name', '').lower():
+            cols = line.get('columns', [])
+            if cols:
+                try:
+                    cogs = float(cols[0])
+                except (ValueError, TypeError):
+                    pass
+    turnover = (cogs / avg_inventory) if avg_inventory else 0
+    return {'cogs': cogs, 'avg_inventory': avg_inventory, 'turnover': round(turnover, 2)}
+
+
+TOOLS = {
+    'get_stock_valuation': get_stock_valuation,
+    'get_price_differences': get_price_differences,
+    'get_cogs_ratio_by_category': get_cogs_ratio_by_category,
+    'find_unusual_adjustments': find_unusual_adjustments,
+    'get_inventory_turnover': get_inventory_turnover,
+}

fusion_accounting/services/tools/journal_review.py

@@ -0,0 +1,220 @@
+import logging
+from odoo import fields
+
+_logger = logging.getLogger(__name__)
+
+ACCOUNT_TYPE_EXPECTED_DIRECTION = {
+    'asset_receivable': 'debit',
+    'asset_cash': 'debit',
+    'asset_current': 'debit',
+    'asset_non_current': 'debit',
+    'asset_prepayments': 'debit',
+    'asset_fixed': 'debit',
+    'liability_payable': 'credit',
+    'liability_credit_card': 'credit',
+    'liability_current': 'credit',
+    'liability_non_current': 'credit',
+    'equity': 'credit',
+    'equity_unaffected': 'credit',
+    'income': 'credit',
+    'income_other': 'credit',
+    'expense': 'debit',
+    'expense_depreciation': 'debit',
+    'expense_direct_cost': 'debit',
+    'off_balance': None,
+}
+
+
+def find_wrong_direction_balances(env, params):
+    balance_data = env['account.move.line'].read_group(
+        [('parent_state', '=', 'posted'), ('company_id', '=', env.company.id)],
+        ['balance:sum'], ['account_id'],
+    )
+    acct_ids = [row['account_id'][0] for row in balance_data if row.get('account_id')]
+    acct_map = {}
+    if acct_ids:
+        for acct in env['account.account'].browse(acct_ids):
+            acct_map[acct.id] = acct
+
+    issues = []
+    for row in balance_data:
+        if not row.get('account_id'):
+            continue
+        acct = acct_map.get(row['account_id'][0])
+        if not acct:
+            continue
+        expected = ACCOUNT_TYPE_EXPECTED_DIRECTION.get(acct.account_type)
+        if not expected:
+            continue
+        balance = row.get('balance', 0) or 0
+        if (expected == 'debit' and balance < -0.01) or (expected == 'credit' and balance > 0.01):
+            issues.append({
+                'account_id': acct.id,
+                'code': acct.code,
+                'name': acct.name,
+                'balance': balance,
+                'expected': expected,
+                'actual': 'credit' if balance < 0 else 'debit',
+            })
+    return {'count': len(issues), 'issues': issues}
+
+
+def find_duplicate_entries(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    domain = [
+        ('state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if date_from:
+        domain.append(('date', '>=', date_from))
+    if date_to:
+        domain.append(('date', '<=', date_to))
+    moves = env['account.move'].search(domain, order='partner_id, amount_total, date')
+
+    duplicates = []
+    prev = None
+    for move in moves:
+        if prev and (
+            prev.partner_id == move.partner_id and prev.partner_id
+            and abs(prev.amount_total - move.amount_total) < 0.01
+            and prev.date == move.date
+            and prev.journal_id == move.journal_id
+        ):
+            duplicates.append({
+                'entry_1': {'id': prev.id, 'name': prev.name},
+                'entry_2': {'id': move.id, 'name': move.name},
+                'partner': move.partner_id.name,
+                'amount': move.amount_total,
+                'date': str(move.date),
+            })
+        prev = move
+    return {'count': len(duplicates), 'duplicates': duplicates[:20]}
+
+
+def find_wrong_account_entries(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    domain = [
+        ('parent_state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if date_from:
+        domain.append(('date', '>=', date_from))
+    if date_to:
+        domain.append(('date', '<=', date_to))
+
+    issues = []
+    tax_accounts = env['account.account'].search([
+        ('account_type', 'in', ('liability_current', 'asset_current')),
+        ('code', '=like', '2005%'),
+        ('company_id', '=', env.company.id),
+    ])
+    if tax_accounts:
+        revenue_on_tax = env['account.move.line'].search(
+            domain + [
+                ('account_id', 'in', tax_accounts.ids),
+                ('product_id', '!=', False),
+            ]
+        )
+        for line in revenue_on_tax[:20]:
+            issues.append({
+                'id': line.id,
+                'move': line.move_id.name,
+                'account': f'{line.account_id.code} {line.account_id.name}',
+                'product': line.product_id.name,
+                'amount': line.balance,
+                'issue': 'Product line on tax account',
+            })
+    return {'count': len(issues), 'issues': issues}
+
+
+def find_sequence_gaps(env, params):
+    moves = env['account.move'].search([
+        ('state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+        ('made_sequence_gap', '=', True),
+    ], order='date desc', limit=50)
+    return {
+        'count': len(moves),
+        'gaps': [{
+            'id': m.id,
+            'name': m.name,
+            'date': str(m.date),
+            'journal': m.journal_id.name,
+        } for m in moves],
+    }
+
+
+def find_draft_entries(env, params):
+    min_age_days = int(params.get('min_age_days', 30))
+    from datetime import timedelta
+    cutoff = fields.Date.today() - timedelta(days=min_age_days)
+    drafts = env['account.move'].search([
+        ('state', '=', 'draft'),
+        ('date', '<=', cutoff),
+        ('company_id', '=', env.company.id),
+    ], order='date asc', limit=50)
+    return {
+        'count': len(drafts),
+        'entries': [{
+            'id': d.id,
+            'name': d.name or 'Draft',
+            'date': str(d.date),
+            'journal': d.journal_id.name,
+            'amount': d.amount_total,
+            'partner': d.partner_id.name if d.partner_id else '',
+        } for d in drafts],
+    }
+
+
+def find_unreconciled_suspense(env, params):
+    suspense_accounts = env['account.account'].search([
+        ('code', '=like', '999%'),
+        ('company_id', '=', env.company.id),
+    ])
+    issues = []
+    for acct in suspense_accounts:
+        balance = sum(env['account.move.line'].search([
+            ('account_id', '=', acct.id),
+            ('parent_state', '=', 'posted'),
+        ]).mapped('balance'))
+        if abs(balance) > 0.01:
+            issues.append({
+                'account_id': acct.id,
+                'code': acct.code,
+                'name': acct.name,
+                'balance': balance,
+            })
+    return {'count': len(issues), 'accounts': issues}
+
+
+def verify_reconciliation_integrity(env, params):
+    partials = env['account.partial.reconcile'].search([
+        ('company_id', '=', env.company.id),
+    ], limit=500)
+    issues = []
+    for p in partials:
+        debit_ok = p.debit_move_id.reconciled or abs(p.debit_move_id.amount_residual) < 0.01
+        credit_ok = p.credit_move_id.reconciled or abs(p.credit_move_id.amount_residual) < 0.01
+        if not debit_ok and not credit_ok:
+            issues.append({
+                'id': p.id,
+                'debit_move': p.debit_move_id.move_id.name,
+                'credit_move': p.credit_move_id.move_id.name,
+                'amount': p.amount,
+                'debit_residual': p.debit_move_id.amount_residual,
+                'credit_residual': p.credit_move_id.amount_residual,
+            })
+    return {'count': len(issues), 'issues': issues[:20]}
+
+
+TOOLS = {
+    'find_wrong_direction_balances': find_wrong_direction_balances,
+    'find_duplicate_entries': find_duplicate_entries,
+    'find_wrong_account_entries': find_wrong_account_entries,
+    'find_sequence_gaps': find_sequence_gaps,
+    'find_draft_entries': find_draft_entries,
+    'find_unreconciled_suspense': find_unreconciled_suspense,
+    'verify_reconciliation_integrity': verify_reconciliation_integrity,
+}

fusion_accounting/services/tools/month_end.py

@@ -0,0 +1,130 @@
+import logging
+from odoo import fields
+
+_logger = logging.getLogger(__name__)
+
+
+def get_close_checklist(env, params):
+    from .bank_reconciliation import get_unreconciled_bank_lines
+    from .journal_review import find_draft_entries, find_sequence_gaps
+    from .hst_management import calculate_hst_balance
+
+    period = params.get('period', str(fields.Date.today())[:7])
+    date_from = f'{period}-01'
+    import calendar
+    year, month = int(period[:4]), int(period[5:7])
+    last_day = calendar.monthrange(year, month)[1]
+    date_to = f'{period}-{last_day:02d}'
+
+    p = {'date_from': date_from, 'date_to': date_to}
+
+    bank = get_unreconciled_bank_lines(env, p)
+    drafts = find_draft_entries(env, {'min_age_days': '0'})
+    gaps = find_sequence_gaps(env, p)
+    hst = calculate_hst_balance(env, p)
+
+    checklist = [
+        {'item': 'Bank Reconciliation', 'status': 'ok' if bank['count'] == 0 else 'attention', 'detail': f"{bank['count']} unreconciled lines"},
+        {'item': 'Draft Entries', 'status': 'ok' if drafts['count'] == 0 else 'attention', 'detail': f"{drafts['count']} draft entries"},
+        {'item': 'Sequence Gaps', 'status': 'ok' if gaps['count'] == 0 else 'warning', 'detail': f"{gaps['count']} gaps found"},
+        {'item': 'HST Balance', 'status': 'info', 'detail': f"Net HST: ${hst['net_hst']:.2f}"},
+    ]
+    return {'period': period, 'checklist': checklist}
+
+
+def get_unreconciled_counts(env, params):
+    accounts = env['account.account'].search([
+        ('reconcile', '=', True),
+        ('company_id', '=', env.company.id),
+    ])
+    result = []
+    for acct in accounts:
+        count = env['account.move.line'].search_count([
+            ('account_id', '=', acct.id),
+            ('reconciled', '=', False),
+            ('parent_state', '=', 'posted'),
+        ])
+        if count > 0:
+            result.append({
+                'account_id': acct.id,
+                'code': acct.code,
+                'name': acct.name,
+                'unreconciled_count': count,
+            })
+    return {'accounts': sorted(result, key=lambda x: -x['unreconciled_count'])}
+
+
+def find_entries_in_locked_period(env, params):
+    company = env.company
+    lock_date = company.fiscalyear_lock_date
+    if not lock_date:
+        return {'status': 'no_lock_date', 'entries': []}
+    entries = env['account.move'].search([
+        ('date', '<=', lock_date),
+        ('state', '=', 'draft'),
+        ('company_id', '=', company.id),
+    ])
+    return {
+        'lock_date': str(lock_date),
+        'count': len(entries),
+        'entries': [{'id': e.id, 'name': e.name, 'date': str(e.date)} for e in entries[:20]],
+    }
+
+
+def get_accrual_status(env, params):
+    accrual_codes = params.get('account_codes', ['2100', '2110', '2120'])
+    result = []
+    for code in accrual_codes:
+        accounts = env['account.account'].search([
+            ('code', '=like', f'{code}%'),
+            ('company_id', '=', env.company.id),
+        ])
+        for acct in accounts:
+            balance = sum(env['account.move.line'].search([
+                ('account_id', '=', acct.id),
+                ('parent_state', '=', 'posted'),
+            ]).mapped('balance'))
+            result.append({'code': acct.code, 'name': acct.name, 'balance': balance})
+    return {'accruals': result}
+
+
+def run_hash_integrity_check(env, params):
+    try:
+        result = env.company._check_hash_integrity()
+        return {
+            'status': 'completed',
+            'results': result.get('results', []),
+            'printing_date': result.get('printing_date', ''),
+        }
+    except Exception as e:
+        return {'error': str(e)}
+
+
+def get_period_summary(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    try:
+        report = env.ref('account_reports.trial_balance_report')
+    except Exception:
+        report = env.ref('account.trial_balance_report', raise_if_not_found=False)
+    if not report:
+        return {'error': 'Trial balance report not found'}
+    options = report.get_options({'date': {'date_from': date_from, 'date_to': date_to}})
+    lines = report._get_lines(options)
+    return {
+        'period': f'{date_from} to {date_to}',
+        'lines': [{
+            'name': l.get('name', ''),
+            'columns': [c.get('no_format', c.get('name', '')) for c in l.get('columns', [])],
+        } for l in lines[:100]],
+    }
+
+
+TOOLS = {
+    'get_close_checklist': get_close_checklist,
+    'get_unreconciled_counts': get_unreconciled_counts,
+    'find_entries_in_locked_period': find_entries_in_locked_period,
+    'get_accrual_status': get_accrual_status,
+    'run_hash_integrity_check': run_hash_integrity_check,
+    'get_period_summary': get_period_summary,
+}

fusion_accounting/services/tools/payroll.py

@@ -0,0 +1,205 @@
+import logging
+from odoo import fields
+
+_logger = logging.getLogger(__name__)
+
+
+def get_payroll_entries(env, params):
+    payroll_journals = env['account.journal'].search([
+        ('name', 'ilike', 'payroll'),
+        ('company_id', '=', env.company.id),
+    ])
+    if not payroll_journals and params.get('journal_id'):
+        payroll_journals = env['account.journal'].browse(int(params['journal_id']))
+    domain = [
+        ('journal_id', 'in', payroll_journals.ids),
+        ('state', '=', 'posted'),
+        ('company_id', '=', env.company.id),
+    ]
+    if params.get('date_from'):
+        domain.append(('date', '>=', params['date_from']))
+    if params.get('date_to'):
+        domain.append(('date', '<=', params['date_to']))
+    entries = env['account.move'].search(domain, order='date desc', limit=50)
+    return {
+        'count': len(entries),
+        'entries': [{
+            'id': e.id, 'name': e.name, 'date': str(e.date),
+            'amount': e.amount_total, 'ref': e.ref or '',
+        } for e in entries],
+    }
+
+
+def compare_payroll_to_bank(env, params):
+    date_from = params.get('date_from')
+    date_to = params.get('date_to')
+    if not date_from or not date_to:
+        return {'error': 'date_from and date_to are required'}
+    payroll_journals = env['account.journal'].search([
+        ('name', 'ilike', 'payroll'), ('company_id', '=', env.company.id),
+    ])
+    payroll_entries = env['account.move'].search([
+        ('journal_id', 'in', payroll_journals.ids),
+        ('state', '=', 'posted'),
+        ('date', '>=', date_from), ('date', '<=', date_to),
+    ])
+    bank_lines = env['account.bank.statement.line'].search([
+        ('date', '>=', date_from), ('date', '<=', date_to),
+        ('company_id', '=', env.company.id),
+    ])
+    payroll_total = sum(e.amount_total for e in payroll_entries)
+    bank_payroll = sum(abs(l.amount) for l in bank_lines if 'payroll' in (l.payment_ref or '').lower())
+    return {
+        'payroll_journal_total': payroll_total,
+        'bank_payroll_total': bank_payroll,
+        'difference': payroll_total - bank_payroll,
+    }
+
+
+def verify_source_deductions(env, params):
+    return {
+        'status': 'info',
+        'message': 'Source deduction verification requires CRA rate tables. Use fusion_payroll for full verification.',
+    }
+
+
+def get_cra_remittance_status(env, params):
+    cra_accounts = env['account.account'].search([
+        ('name', 'ilike', 'CRA'),
+        ('company_id', '=', env.company.id),
+    ])
+    result = []
+    for acct in cra_accounts:
+        balance = sum(env['account.move.line'].search([
+            ('account_id', '=', acct.id),
+            ('parent_state', '=', 'posted'),
+        ]).mapped('balance'))
+        result.append({'code': acct.code, 'name': acct.name, 'balance': balance})
+    return {'accounts': result}
+
+
+def find_unmatched_payroll_cheques(env, params):
+    bank_lines = env['account.bank.statement.line'].search([
+        ('is_reconciled', '=', False),
+        ('company_id', '=', env.company.id),
+        ('payment_ref', 'ilike', 'cheque'),
+    ])
+    return {
+        'count': len(bank_lines),
+        'cheques': [{
+            'id': l.id, 'date': str(l.date),
+            'ref': l.payment_ref, 'amount': l.amount,
+        } for l in bank_lines[:30]],
+    }
+
+
+def parse_payroll_summary(env, params):
+    import re
+    raw_data = params.get('data', '')
+    if not raw_data:
+        return {'error': 'No payroll data provided'}
+
+    lines = raw_data.strip().split('\n')
+    entries = []
+    totals = {'gross': 0, 'cpp': 0, 'ei': 0, 'tax': 0, 'net': 0}
+
+    for line in lines:
+        amounts = re.findall(r'\$?([\d,]+\.?\d*)', line)
+        if len(amounts) >= 2:
+            name_part = re.sub(r'\$?[\d,]+\.?\d*', '', line).strip(' \t,|-')
+            parsed_amounts = [float(a.replace(',', '')) for a in amounts]
+            entry = {'name': name_part or 'Employee', 'amounts': parsed_amounts}
+            if len(parsed_amounts) >= 5:
+                entry.update({
+                    'gross': parsed_amounts[0],
+                    'cpp': parsed_amounts[1],
+                    'ei': parsed_amounts[2],
+                    'tax': parsed_amounts[3],
+                    'net': parsed_amounts[4] if len(parsed_amounts) > 4 else parsed_amounts[0] - sum(parsed_amounts[1:4]),
+                })
+                for k in ('gross', 'cpp', 'ei', 'tax', 'net'):
+                    totals[k] += entry.get(k, 0)
+            entries.append(entry)
+
+    return {
+        'status': 'parsed',
+        'employee_count': len(entries),
+        'entries': entries,
+        'totals': totals,
+        'raw_lines': len(lines),
+    }
+
+
+def create_payroll_journal_entry(env, params):
+    journal_id = int(params['journal_id'])
+    date = params['date']
+    lines_data = params['lines']
+    move_vals = {
+        'journal_id': journal_id,
+        'date': date,
+        'ref': params.get('ref', 'Payroll Entry'),
+        'line_ids': [(0, 0, {
+            'account_id': int(line['account_id']),
+            'name': line.get('name', 'Payroll'),
+            'debit': float(line.get('debit', 0)),
+            'credit': float(line.get('credit', 0)),
+            'partner_id': int(line['partner_id']) if line.get('partner_id') else False,
+        }) for line in lines_data],
+    }
+    move = env['account.move'].create(move_vals)
+    return {'status': 'created', 'move_id': move.id, 'name': move.name}
+
+
+def get_payroll_schedule(env, params):
+    return {'status': 'info', 'message': 'Payroll schedule available via fusion_payroll module.'}
+
+
+def match_payroll_cheques(env, params):
+    st_line_id = int(params['statement_line_id'])
+    move_line_ids = [int(x) for x in params['move_line_ids']]
+    st_line = env['account.bank.statement.line'].browse(st_line_id)
+    st_line.set_line_bank_statement_line(move_line_ids)
+    return {'status': 'matched', 'statement_line_id': st_line_id}
+
+
+def verify_payroll_deductions(env, params):
+    return verify_source_deductions(env, params)
+
+
+def get_cra_remittance_due(env, params):
+    return get_cra_remittance_status(env, params)
+
+
+def prepare_cra_payment(env, params):
+    return create_payroll_journal_entry(env, params)
+
+
+def generate_t4(env, params):
+    return {'status': 'info', 'message': 'T4 generation available via fusion_payroll module.'}
+
+
+def generate_roe(env, params):
+    return {'status': 'info', 'message': 'ROE generation available via fusion_payroll module.'}
+
+
+def get_payroll_cost_report(env, params):
+    return get_payroll_entries(env, params)
+
+
+TOOLS = {
+    'get_payroll_entries': get_payroll_entries,
+    'compare_payroll_to_bank': compare_payroll_to_bank,
+    'verify_source_deductions': verify_source_deductions,
+    'get_cra_remittance_status': get_cra_remittance_status,
+    'find_unmatched_payroll_cheques': find_unmatched_payroll_cheques,
+    'parse_payroll_summary': parse_payroll_summary,
+    'create_payroll_journal_entry': create_payroll_journal_entry,
+    'get_payroll_schedule': get_payroll_schedule,
+    'match_payroll_cheques': match_payroll_cheques,
+    'verify_payroll_deductions': verify_payroll_deductions,
+    'get_cra_remittance_due': get_cra_remittance_due,
+    'prepare_cra_payment': prepare_cra_payment,
+    'generate_t4': generate_t4,
+    'generate_roe': generate_roe,
+    'get_payroll_cost_report': get_payroll_cost_report,
+}

fusion_accounting/services/tools/reporting.py

@@ -0,0 +1,117 @@
+import logging
+import base64
+
+_logger = logging.getLogger(__name__)
+
+
+def _get_report(env, ref_id):
+    try:
+        return env.ref(ref_id)
+    except Exception:
+        return None
+
+
+def _run_report(env, report_ref, params):
+    report = _get_report(env, report_ref)
+    if not report:
+        return {'error': f'Report {report_ref} not found'}
+    date_opts = {}
+    if params.get('date_from'):
+        date_opts['date_from'] = params['date_from']
+    if params.get('date_to'):
+        date_opts['date_to'] = params['date_to']
+    options = report.get_options({'date': date_opts} if date_opts else {})
+    lines = report._get_lines(options)
+    return {
+        'report_name': report.name,
+        'lines': [{
+            'name': l.get('name', ''),
+            'level': l.get('level', 0),
+            'columns': [c.get('no_format', c.get('name', '')) for c in l.get('columns', [])],
+        } for l in lines[:100]],
+    }
+
+
+def get_profit_loss(env, params):
+    return _run_report(env, 'account_reports.profit_and_loss', params)
+
+
+def get_balance_sheet(env, params):
+    return _run_report(env, 'account_reports.balance_sheet', params)
+
+
+def get_trial_balance(env, params):
+    return _run_report(env, 'account_reports.trial_balance_report', params)
+
+
+def get_cash_flow(env, params):
+    return _run_report(env, 'account_reports.cash_flow_statement', params)
+
+
+def compare_periods(env, params):
+    report_ref = params.get('report_ref', 'account_reports.profit_and_loss')
+    report = _get_report(env, report_ref)
+    if not report:
+        return {'error': f'Report {report_ref} not found'}
+
+    period1 = _run_report(env, report_ref, {
+        'date_from': params.get('period1_from'),
+        'date_to': params.get('period1_to'),
+    })
+    period2 = _run_report(env, report_ref, {
+        'date_from': params.get('period2_from'),
+        'date_to': params.get('period2_to'),
+    })
+    return {'period_1': period1, 'period_2': period2}
+
+
+def answer_financial_question(env, params):
+    question = params.get('question', '')
+    sql_query = params.get('sql_query')
+    if sql_query:
+        return {'error': 'Direct SQL not permitted. Use report tools instead.'}
+    return {'status': 'info', 'message': f'Use specific report tools to answer: {question}'}
+
+
+def export_report(env, params):
+    report_ref = params.get('report_ref', 'account_reports.profit_and_loss')
+    fmt = params.get('format', 'pdf')
+    report = _get_report(env, report_ref)
+    if not report:
+        return {'error': f'Report {report_ref} not found'}
+    date_opts = {}
+    if params.get('date_from'):
+        date_opts['date_from'] = params['date_from']
+    if params.get('date_to'):
+        date_opts['date_to'] = params['date_to']
+    options = report.get_options({'date': date_opts} if date_opts else {})
+
+    try:
+        if fmt == 'xlsx':
+            result = report.dispatch_report_action(options, 'export_to_xlsx')
+        else:
+            result = report.dispatch_report_action(options, 'export_to_pdf')
+
+        if isinstance(result, dict) and result.get('file_content'):
+            return {
+                'file_name': result.get('file_name', f'report.{fmt}'),
+                'file_type': result.get('file_type', fmt),
+                'file_content_b64': base64.b64encode(result['file_content']).decode(),
+            }
+        return {
+            'status': 'generated',
+            'message': f'Report exported as {fmt}. Use the Odoo UI to download.',
+        }
+    except Exception as e:
+        return {'error': f'Export failed: {str(e)}'}
+
+
+TOOLS = {
+    'get_profit_loss': get_profit_loss,
+    'get_balance_sheet': get_balance_sheet,
+    'get_trial_balance': get_trial_balance,
+    'get_cash_flow': get_cash_flow,
+    'compare_periods': compare_periods,
+    'answer_financial_question': answer_financial_question,
+    'export_report': export_report,
+}