Skip to content

src.tools.core.parsers.base_tool_call_parser.BaseToolCallParser

Bases: ABC

Source code in src/tools/core/parsers/base_tool_call_parser.py 
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
class BaseToolCallParser(ABC):
    def __init__(self, config: Dict[str, Any]):
        """Abstract base class for parsing tool calls from text.

        This class provides a framework for implementing tool call parsers
        with common functionality for cleaning, validation, and error handling.

        Attributes:
            config (Dict[str, Any]): Configuration dictionary for parsing options.

        Example:
            ```python
            class MyParser(BaseToolCallParser):
                def extract(self, text: str) -> Dict[str, Any]:
                    # Implementation
                    return {"tool_calls": [...]}

            parser = MyParser({"clean_tokens": ["<START>", "<END>"]})
            result = parser.parse("some text with tool calls")
            ```
        """
        self.config = config
        self.logger = logging.getLogger(__name__)

    def parse(self, text: str) -> Dict[str, Any]:
        """Main entry point for parsing tool calls from text.

        Orchestrates the parsing process through cleaning, extraction,
        and validation steps.

        Args:
            text (str): Raw input text containing tool calls.

        Returns:
            Dict[str, Any]: Parsed tool calls or error information.
                Success format: {"tool_calls": [...]}
                Error format: {"error": "error message"}
        """
        cleaned_text = self.clean_text(text)
        try:
            extracted_data = self.extract(cleaned_text)
            if "tool_calls" in extracted_data:
                for tool_call in extracted_data["tool_calls"]:
                    if "parameters" in tool_call:
                        tool_call["arguments"] = tool_call.pop("parameters")
            if "parameters" in extracted_data:
                extracted_data["arguments"] = extracted_data.pop("parameters")
                print(f"updated extracted_data: {extracted_data}")
            if "error" not in extracted_data:
                if self.validate(extracted_data):
                    return extracted_data
            return extracted_data
        except ValueError as e:
            self.logger.error(f"Validation error: {str(e)}")
            return {"error": str(e)}
        except Exception as e:
            self.logger.error("Unexpected error during parsing", exc_info=True)
            return {"error": f"Unexpected error: {str(e)}"}

    def clean_text(self, text: str) -> str:
        """Clean input text by removing specified tokens.

        Args:
            text (str): Raw input text to clean.

        Returns:
            str: Cleaned text with tokens removed and whitespace stripped.
        """
        tokens = self.config.get("clean_tokens", [])
        for token in tokens:
            text = text.replace(token, "")
        return text.strip()

    @staticmethod
    def validate(data: Dict[str, Any]) -> bool:
        """Validate the structure of extracted tool calls.

        Args:
            data (Dict[str, Any]): Extracted tool call data to validate.

        Returns:
            bool: True if validation passes.

        Raises:
            ValueError: If validation fails with specific reason.
        """
        tool_calls = data.get("tool_calls")
        if not isinstance(tool_calls, list):
            raise ValueError("Expected a list of tool calls")

        for call in tool_calls:
            if not isinstance(call, dict):
                raise ValueError("Each tool call must be a dictionary")
            if "name" not in call or "arguments" not in call:
                raise ValueError("Each tool call must contain 'name' and ('arguments' or 'parameters') keys)")

        return True

    @abstractmethod
    def extract(self, text: str) -> Dict[str, Any]:
        """Extract tool calls from cleaned text.

        Must be implemented by subclasses to define specific extraction logic.

        Args:
            text (str): Cleaned input text.

        Returns:
            Dict[str, Any]: Extracted tool calls or error information.
        """
        pass

__init__(config)

Abstract base class for parsing tool calls from text.

This class provides a framework for implementing tool call parsers with common functionality for cleaning, validation, and error handling.

Attributes:

Name Type Description
config Dict[str, Any]

Configuration dictionary for parsing options.
Example 
class MyParser(BaseToolCallParser):
    def extract(self, text: str) -> Dict[str, Any]:
        # Implementation
        return {"tool_calls": [...]}

parser = MyParser({"clean_tokens": ["<START>", "<END>"]})
result = parser.parse("some text with tool calls")
Source code in src/tools/core/parsers/base_tool_call_parser.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def __init__(self, config: Dict[str, Any]):
    """Abstract base class for parsing tool calls from text.

    This class provides a framework for implementing tool call parsers
    with common functionality for cleaning, validation, and error handling.

    Attributes:
        config (Dict[str, Any]): Configuration dictionary for parsing options.

    Example:
        ```python
        class MyParser(BaseToolCallParser):
            def extract(self, text: str) -> Dict[str, Any]:
                # Implementation
                return {"tool_calls": [...]}

        parser = MyParser({"clean_tokens": ["<START>", "<END>"]})
        result = parser.parse("some text with tool calls")
        ```
    """
    self.config = config
    self.logger = logging.getLogger(__name__)

clean_text(text)

Clean input text by removing specified tokens.

Parameters:

Name Type Description Default
text str

Raw input text to clean.

 required

Returns:

Name Type Description
str str

Cleaned text with tokens removed and whitespace stripped.
Source code in src/tools/core/parsers/base_tool_call_parser.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
def clean_text(self, text: str) -> str:
    """Clean input text by removing specified tokens.

    Args:
        text (str): Raw input text to clean.

    Returns:
        str: Cleaned text with tokens removed and whitespace stripped.
    """
    tokens = self.config.get("clean_tokens", [])
    for token in tokens:
        text = text.replace(token, "")
    return text.strip()

extract(text) abstractmethod

Extract tool calls from cleaned text.

Must be implemented by subclasses to define specific extraction logic.

Parameters:

Name Type Description Default
text str

Cleaned input text.

 required

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Extracted tool calls or error information.
Source code in src/tools/core/parsers/base_tool_call_parser.py 
106
107
108
109
110
111
112
113
114
115
116
117
118
@abstractmethod
def extract(self, text: str) -> Dict[str, Any]:
    """Extract tool calls from cleaned text.

    Must be implemented by subclasses to define specific extraction logic.

    Args:
        text (str): Cleaned input text.

    Returns:
        Dict[str, Any]: Extracted tool calls or error information.
    """
    pass

parse(text)

Main entry point for parsing tool calls from text.

Orchestrates the parsing process through cleaning, extraction, and validation steps.

Parameters:

Name Type Description Default
text str

Raw input text containing tool calls.

 required

Returns:

Type Description
Dict[str, Any]

Dict[str, Any]: Parsed tool calls or error information. Success format: {"tool_calls": [...]} Error format: {"error": "error message"}
Source code in src/tools/core/parsers/base_tool_call_parser.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def parse(self, text: str) -> Dict[str, Any]:
    """Main entry point for parsing tool calls from text.

    Orchestrates the parsing process through cleaning, extraction,
    and validation steps.

    Args:
        text (str): Raw input text containing tool calls.

    Returns:
        Dict[str, Any]: Parsed tool calls or error information.
            Success format: {"tool_calls": [...]}
            Error format: {"error": "error message"}
    """
    cleaned_text = self.clean_text(text)
    try:
        extracted_data = self.extract(cleaned_text)
        if "tool_calls" in extracted_data:
            for tool_call in extracted_data["tool_calls"]:
                if "parameters" in tool_call:
                    tool_call["arguments"] = tool_call.pop("parameters")
        if "parameters" in extracted_data:
            extracted_data["arguments"] = extracted_data.pop("parameters")
            print(f"updated extracted_data: {extracted_data}")
        if "error" not in extracted_data:
            if self.validate(extracted_data):
                return extracted_data
        return extracted_data
    except ValueError as e:
        self.logger.error(f"Validation error: {str(e)}")
        return {"error": str(e)}
    except Exception as e:
        self.logger.error("Unexpected error during parsing", exc_info=True)
        return {"error": f"Unexpected error: {str(e)}"}

validate(data) staticmethod

Validate the structure of extracted tool calls.

Parameters:

Name Type Description Default
data Dict[str, Any]

Extracted tool call data to validate.

 required

Returns:

Name Type Description
bool bool

True if validation passes.

Raises:

Type Description
ValueError

If validation fails with specific reason.
Source code in src/tools/core/parsers/base_tool_call_parser.py 
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
@staticmethod
def validate(data: Dict[str, Any]) -> bool:
    """Validate the structure of extracted tool calls.

    Args:
        data (Dict[str, Any]): Extracted tool call data to validate.

    Returns:
        bool: True if validation passes.

    Raises:
        ValueError: If validation fails with specific reason.
    """
    tool_calls = data.get("tool_calls")
    if not isinstance(tool_calls, list):
        raise ValueError("Expected a list of tool calls")

    for call in tool_calls:
        if not isinstance(call, dict):
            raise ValueError("Each tool call must be a dictionary")
        if "name" not in call or "arguments" not in call:
            raise ValueError("Each tool call must contain 'name' and ('arguments' or 'parameters') keys)")

    return True