Optimize tool call reactor handler ordering

[matdev83]

Summary

• cache the tool call reactor's handler list so we stop re-sorting on every tool invocation

Testing

• python -m pytest -o addopts='' tests/unit/core/services/test_tool_call_reactor_service.py
• python -m pytest -o addopts='' (fails: missing pytest_asyncio/respx/pytest_httpx in environment)

---

https://chatgpt.com/codex/tasks/task_e_68ec27b5f5f08333be56cce2d6aca430

Summary by CodeRabbit

• Refactor
  • Optimized tool-call processing by precomputing and caching handler priority order, eliminating per-request sorting.
  • Delivers faster response times, reduced CPU overhead, and more predictable execution under high concurrency.
  • Preserves existing behavior and history tracking with no changes to public APIs.
  • No user action required.

[coderabbitai]

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title Check	✅ Passed	The title directly reflects the core change of caching and ordering handlers for improved performance in the tool call reactor, and it is concise and specific without extraneous detail.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch codex/fix-performance-issues-in-codebase

---

📜 Recent review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between dd216cf and 158bd5a.

📒 Files selected for processing (1)

• src/core/services/tool_call_reactor_service.py (6 hunks)

🧰 Additional context used

📓 Path-based instructions (2)

**/*.py

📄 CodeRabbit inference engine (AGENTS.md)

**/*.py: Avoid using emojis in Python code comments or docstrings
Follow PEP 8 and use type hints for all functions
Import order must be: standard library, third-party, then local imports, separated by blank lines
Naming conventions: snake_case for variables and functions; PascalCase for classes
Error handling: use specific exceptions and include meaningful error messages
Prefer f-strings for string formatting

Files:

• src/core/services/tool_call_reactor_service.py

src/**/*.py

📄 CodeRabbit inference engine (AGENTS.md)

src/**/*.py: Catch specific exceptions; avoid broad except Exception blocks
If a broad exception must be caught, log with exc_info=True and re-raise a specific custom exception
Use the most specific exception class from src.core.common.exceptions that accurately describes the error
Provide clear, helpful error messages and include relevant details in the details dictionary of custom exceptions

Files:

• src/core/services/tool_call_reactor_service.py

🧬 Code graph analysis (1)

src/core/services/tool_call_reactor_service.py (1)

src/core/interfaces/tool_call_reactor_interface.py (2)

• IToolCallHandler (60-98)
• priority (74-75)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: test (3.10)

🔇 Additional comments (4)

src/core/services/tool_call_reactor_service.py (4)

42-42: LGTM! Clean cache initialization.

The tuple cache for sorted handlers is correctly initialized as an empty tuple. The tuple is appropriately used here for immutability, ensuring thread-safe reads.

---

186-195: LGTM! Efficient caching implementation.

The _refresh_sorted_handlers method correctly recomputes the handler ordering by priority in descending order. Using a tuple ensures the cached result is immutable, which supports safe concurrent reads in process_tool_call.

---

65-65: LGTM! Cache invalidation is correctly placed.

The calls to _refresh_sorted_handlers() appropriately invalidate and refresh the cache after any handler registration or unregistration, ensuring the cached ordering stays consistent with the handler collection.

Also applies to: 84-84, 103-103

---

145-146: LGTM! Optimization eliminates redundant sorting.

The change from dynamic sorting to using the precomputed _sorted_handlers cache eliminates O(n log n) overhead on every tool invocation. The comment accurately reflects the new behavior. This is a solid performance improvement with no functional impact.

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}