Skip to content

Client

A ToolClient connects to a ToolServer and interfaces with its tools

Source code in blue/tools/client.py 
 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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
class ToolClient:
    """A ToolClient connects to a ToolServer and interfaces with its tools"""

    def __init__(self, name, properties={}):
        """Initialize a ToolClient instance.

        Parameters:
            name: Name of the tool client
            properties (dict): Properties of the tool client
        """
        self.name = name

        self._initialize(properties=properties)

        self._start()

    ###### initialization
    def _initialize(self, properties=None):
        """Initialize the tool client with properties and logger.

        Parameters:
            properties: Properties to override default properties.
        """
        self._initialize_properties()
        self._update_properties(properties=properties)

        self._initialize_logger()

    def _initialize_properties(self):
        """Initialize default properties for tool client."""
        self.properties = {}

        # connection properties
        self._initialize_connection_properties()

    def _update_properties(self, properties=None):
        """Update properties with given properties.

        Parameters:
            properties: Properties to override default properties.
        """
        if properties is None:
            return

        # override
        for p in properties:
            self.properties[p] = properties[p]

    def _initialize_connection_properties(self):
        """Initialize default connection properties."""
        connection_properties = {}

        connection_properties['protocol'] = 'default'
        self.properties['connection'] = connection_properties

    def _initialize_logger(self):
        """Initialize logger for the tool client."""
        self.logger = log_utils.CustomLogger()
        # customize log
        self.logger.set_config_data(
            "stack",
            "%(call_stack)s",
        )
        self.logger.set_config_data("tool_client", self.name, -1)

    ###### connection
    def _start_connection(self):
        """Starts a connection to the tool server."""
        connection = self.properties['connection']

        self.connection = self._connect(**connection)

    def _stop_connection(self):
        """Stops the connection to the tool server."""
        self._disconnect()

    def _connect(self, **connection):
        """Connect to the tool server.

        Returns:
            A connection object or None
        """
        return None

    def _disconnect(self):
        """Disconnect from the tool server."""
        return None

    def _start(self):
        """Start the tool server, connect, and initialize tools."""
        # self.logger.info('Starting session {name}'.format(name=self.name))
        self._start_connection()

        self.logger.info('Started server {name}'.format(name=self.name))

    def _stop(self):
        """Stop the tool server and disconnect."""
        self._stop_connection()

        self.logger.info('Stopped server {name}'.format(name=self.name))

    ######### server
    def fetch_metadata(self):
        """Fetch metadata from the tool server.

        Returns:
            Metadata dictionary
        """
        return {}

    ######### tool
    def fetch_tools(self):
        """Fetch list of available tools from the tool server.

        Returns:
            List of tools
        """
        return []

    def fetch_tool_metadata(self, tool):
        """Fetch metadata for a specific tool from the tool server.

        Parameters:
            tool: Name of the tool

        Returns:
            Metadata dictionary for the tool
        """
        return {}

    def execute_tool(self, tool, args, kwargs):
        """Execute a specific tool on the tool server.

        Parameters:
            tool: Name of the tool
            args: Args for the tool function
            kwargs: Keyword args for the tool function

        Returns:

        """
        return [{}]

__init__(name, properties={})

Initialize a ToolClient instance.

Parameters:

Name Type Description Default
name

Name of the tool client

 required
properties dict

Properties of the tool client

 {}
Source code in blue/tools/client.py 
16
17
18
19
20
21
22
23
24
25
26
27
def __init__(self, name, properties={}):
    """Initialize a ToolClient instance.

    Parameters:
        name: Name of the tool client
        properties (dict): Properties of the tool client
    """
    self.name = name

    self._initialize(properties=properties)

    self._start()

execute_tool(tool, args, kwargs)

Execute a specific tool on the tool server.

Parameters:

Name Type Description Default
tool

Name of the tool

 required
args

Args for the tool function

 required
kwargs

Keyword args for the tool function

 required

Returns:

Source code in blue/tools/client.py 
143
144
145
146
147
148
149
150
151
152
153
154
def execute_tool(self, tool, args, kwargs):
    """Execute a specific tool on the tool server.

    Parameters:
        tool: Name of the tool
        args: Args for the tool function
        kwargs: Keyword args for the tool function

    Returns:

    """
    return [{}]

fetch_metadata()

Fetch metadata from the tool server.

Returns:

Type Description

Metadata dictionary
Source code in blue/tools/client.py 
115
116
117
118
119
120
121
def fetch_metadata(self):
    """Fetch metadata from the tool server.

    Returns:
        Metadata dictionary
    """
    return {}

fetch_tool_metadata(tool)

Fetch metadata for a specific tool from the tool server.

Parameters:

Name Type Description Default
tool

Name of the tool

 required

Returns:

Type Description

Metadata dictionary for the tool
Source code in blue/tools/client.py 
132
133
134
135
136
137
138
139
140
141
def fetch_tool_metadata(self, tool):
    """Fetch metadata for a specific tool from the tool server.

    Parameters:
        tool: Name of the tool

    Returns:
        Metadata dictionary for the tool
    """
    return {}

fetch_tools()

Fetch list of available tools from the tool server.

Returns:

Type Description

List of tools
Source code in blue/tools/client.py 
124
125
126
127
128
129
130
def fetch_tools(self):
    """Fetch list of available tools from the tool server.

    Returns:
        List of tools
    """
    return []
Last update: 2025-10-07