Willem Jiang
bcc403ecd3
* feat: implement tool-specific interrupts for create_react_agent (#572) Add selective tool interrupt capability allowing interrupts before specific tools rather than all tools. Users can now configure which tools trigger interrupts via the interrupt_before_tools parameter. Changes: - Create ToolInterceptor class to handle tool-specific interrupt logic - Add interrupt_before_tools parameter to create_agent() function - Extend Configuration with interrupt_before_tools field - Add interrupt_before_tools to ChatRequest API - Update nodes.py to pass interrupt configuration to agents - Update app.py workflow to support tool interrupt configuration - Add comprehensive unit tests for tool interceptor Features: - Selective tool interrupts: interrupt only specific tools by name - Approval keywords: recognize user approval (approved, proceed, accept, etc.) - Backward compatible: optional parameter, existing code unaffected - Flexible: works with default tools and MCP-powered tools - Works with existing resume mechanism for seamless workflow Example usage: request = ChatRequest( messages=[...], interrupt_before_tools=['db_tool', 'sensitive_api'] ) * test: add comprehensive integration tests for tool-specific interrupts (#572) Add 24 integration tests covering all aspects of the tool interceptor feature: Test Coverage: - Agent creation with tool interrupts - Configuration support (with/without interrupts) - ChatRequest API integration - Multiple tools with selective interrupts - User approval/rejection flows - Tool wrapping and functionality preservation - Error handling and edge cases - Approval keyword recognition - Complex tool inputs - Logging and monitoring All tests pass with 100% coverage of tool interceptor functionality. Tests verify: ✓ Selective tool interrupts work correctly ✓ Only specified tools trigger interrupts ✓ Non-matching tools execute normally ✓ User feedback is properly parsed ✓ Tool functionality is preserved after wrapping ✓ Error handling works as expected ✓ Configuration options are properly respected ✓ Logging provides useful debugging info * fix: mock get_llm_by_type in agent creation test Fix test_agent_creation_with_tool_interrupts which was failing because get_llm_by_type() was being called before create_react_agent was mocked. Changes: - Add mock for get_llm_by_type in test - Use context manager composition for multiple patches - Test now passes and validates tool wrapping correctly All 24 integration tests now pass successfully. * refactor: use mock assertion methods for consistent and clearer error messages Update integration tests to use mock assertion methods instead of direct attribute checking for consistency and clearer error messages: Changes: - Replace 'assert mock_interrupt.called' with 'mock_interrupt.assert_called()' - Replace 'assert not mock_interrupt.called' with 'mock_interrupt.assert_not_called()' Benefits: - Consistent with pytest-mock and unittest.mock best practices - Clearer error messages when assertions fail - Better IDE autocompletion support - More professional test code All 42 tests pass with improved assertion patterns. * refactor: use default_factory for interrupt_before_tools consistency Improve consistency between ChatRequest and Configuration implementations: Changes: - ChatRequest.interrupt_before_tools: Use Field(default_factory=list) instead of Optional[None] - Remove unnecessary 'or []' conversion in app.py line 505 - Aligns with Configuration.interrupt_before_tools implementation pattern - No functional changes - all tests still pass Benefits: - Consistent field definition across codebase - Simpler and cleaner code - Reduced chance of None/empty list bugs - Better alignment with Pydantic best practices All 42 tests passing. * refactor: improve tool input formatting in interrupt messages Enhance tool input representation for better readability in interrupt messages: Changes: - Add json import for better formatting - Create _format_tool_input() static method with JSON serialization - Use JSON formatting for dicts, lists, tuples with indent=2 - Fall back to str() for non-serializable types - Handle None input specially (returns 'No input') - Improve interrupt message formatting with better spacing Benefits: - Complex tool inputs now display as readable JSON - Nested structures are properly indented and visible - Better user experience when reviewing tool inputs before approval - Handles edge cases gracefully with fallbacks - Improved logging output for debugging Example improvements: Before: {'query': 'SELECT...', 'limit': 10, 'nested': {'key': 'value'}} After: { "query": "SELECT...", "limit": 10, "nested": { "key": "value" } } All 42 tests still passing. * test: add comprehensive unit tests for tool input formatting
75 lines
2.6 KiB
Python
75 lines
2.6 KiB
Python
# Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
|
|
# SPDX-License-Identifier: MIT
|
|
|
|
import logging
|
|
import os
|
|
from dataclasses import dataclass, field, fields
|
|
from typing import Any, Optional
|
|
|
|
from langchain_core.runnables import RunnableConfig
|
|
|
|
from src.config.loader import get_bool_env, get_int_env, get_str_env
|
|
from src.config.report_style import ReportStyle
|
|
from src.rag.retriever import Resource
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def get_recursion_limit(default: int = 25) -> int:
|
|
"""Get the recursion limit from environment variable or use default.
|
|
|
|
Args:
|
|
default: Default recursion limit if environment variable is not set or invalid
|
|
|
|
Returns:
|
|
int: The recursion limit to use
|
|
"""
|
|
env_value_str = get_str_env("AGENT_RECURSION_LIMIT", str(default))
|
|
parsed_limit = get_int_env("AGENT_RECURSION_LIMIT", default)
|
|
|
|
if parsed_limit > 0:
|
|
logger.info(f"Recursion limit set to: {parsed_limit}")
|
|
return parsed_limit
|
|
else:
|
|
logger.warning(
|
|
f"AGENT_RECURSION_LIMIT value '{env_value_str}' (parsed as {parsed_limit}) is not positive. "
|
|
f"Using default value {default}."
|
|
)
|
|
return default
|
|
|
|
|
|
@dataclass(kw_only=True)
|
|
class Configuration:
|
|
"""The configurable fields."""
|
|
|
|
resources: list[Resource] = field(
|
|
default_factory=list
|
|
) # Resources to be used for the research
|
|
max_plan_iterations: int = 1 # Maximum number of plan iterations
|
|
max_step_num: int = 3 # Maximum number of steps in a plan
|
|
max_search_results: int = 3 # Maximum number of search results
|
|
mcp_settings: dict = None # MCP settings, including dynamic loaded tools
|
|
report_style: str = ReportStyle.ACADEMIC.value # Report style
|
|
enable_deep_thinking: bool = False # Whether to enable deep thinking
|
|
enforce_web_search: bool = (
|
|
False # Enforce at least one web search step in every plan
|
|
)
|
|
interrupt_before_tools: list[str] = field(
|
|
default_factory=list
|
|
) # List of tool names to interrupt before execution
|
|
|
|
@classmethod
|
|
def from_runnable_config(
|
|
cls, config: Optional[RunnableConfig] = None
|
|
) -> "Configuration":
|
|
"""Create a Configuration instance from a RunnableConfig."""
|
|
configurable = (
|
|
config["configurable"] if config and "configurable" in config else {}
|
|
)
|
|
values: dict[str, Any] = {
|
|
f.name: os.environ.get(f.name.upper(), configurable.get(f.name))
|
|
for f in fields(cls)
|
|
if f.init
|
|
}
|
|
return cls(**{k: v for k, v in values.items() if v})
|