Skip to content

Local client

Bases: ToolClient

A LocalToolClient connects to local tools and interfaces with them

Source code in blue/tools/clients/local_client.py 
 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
class LocalToolClient(ToolClient):
    """A LocalToolClient connects to local tools and interfaces with them"""

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

        Parameters:
            name: Name of the tool client
            tools: A dictionary of tool name to Tool object
            properties: Properties of the tool client
        """
        super().__init__(name, properties=properties)

        self.tools = tools

    ###### connection
    def _initialize_connection_properties(self):
        """Initialize default connection properties for local tool client."""
        super()._initialize_connection_properties()

        # set host, port, protocol
        self.properties['connection']['protocol'] = 'local'

    ###### connection
    def _connect(self, **connection):
        """Connect to local tools.

        Returns:
            An empty dictionary since no connection is necessary for local tools.
        """
        c = copy.deepcopy(connection)
        if 'protocol' in c:
            del c['protocol']

        # no connection necessary
        return {}

    def _disconnect(self):
        """Disconnect from local tools.

        Returns:
            None
        """
        # TODO:
        return None

    ######### server
    def fetch_metadata(self):
        """Fetch metadata for the local tool client.

        Returns:
            An empty dictionary since no metadata is necessary for local tools.
        """
        return {}

    ######### tool
    def fetch_tools(self):
        """Get a list of available tools on local client.

        Returns:
            List of tool names
        """
        tools = list(self.tools.keys())
        return tools

    def fetch_tool_metadata(self, tool):
        """Fetch metadata for a specific tool on local client.

        Parameters:
            tool: Name of the tool

        Returns:
            Metadata dictionary for the tool
        """
        metadata = {}

        if tool in self.tools:
            tool_obj = self.tools[tool]
            p = {}
            p = json_utils.merge_json(p, tool_obj.properties)
            p = json_utils.merge_json(p, {"signature": tool_obj.get_signature()})
            metadata = {"name": tool_obj.name, "description": tool_obj.description, "properties": p}
        return metadata

    ######### execute tool
    def execute_tool(self, tool, args, kwargs):
        """Execute a specific tool on local client.

        Parameters:
            tool: Name of the tool
            args: Arguments for the tool function
            kwargs: Keyword arguments for the tool function

        Raises:
            Exception: If no tool matches the given name

        Returns:
            Result of the tool function execution or validation result
        """
        if tool is None:
            raise Exception("No tool matching...")

        result = None

        if tool in self.tools:
            tool_obj = self.tools[tool]

            valid = tool_obj.validator(**kwargs)
            if valid:
                return tool_obj.function(**kwargs)
            else:
                return valid

        return result

__init__(name, tools={}, properties={})

Initialize a LocalToolClient instance.

Parameters:

Name Type Description Default
name

Name of the tool client

 required
tools

A dictionary of tool name to Tool object

 {}
properties

Properties of the tool client

 {}
Source code in blue/tools/clients/local_client.py 
21
22
23
24
25
26
27
28
29
30
31
def __init__(self, name, tools={}, properties={}):
    """Initialize a LocalToolClient instance.

    Parameters:
        name: Name of the tool client
        tools: A dictionary of tool name to Tool object
        properties: Properties of the tool client
    """
    super().__init__(name, properties=properties)

    self.tools = tools

execute_tool(tool, args, kwargs)

Execute a specific tool on local client.

Parameters:

Name Type Description Default
tool

Name of the tool

 required
args

Arguments for the tool function

 required
kwargs

Keyword arguments for the tool function

 required

Raises:

Type Description
Exception

If no tool matches the given name

Returns:

Type Description

Result of the tool function execution or validation result
Source code in blue/tools/clients/local_client.py 
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
def execute_tool(self, tool, args, kwargs):
    """Execute a specific tool on local client.

    Parameters:
        tool: Name of the tool
        args: Arguments for the tool function
        kwargs: Keyword arguments for the tool function

    Raises:
        Exception: If no tool matches the given name

    Returns:
        Result of the tool function execution or validation result
    """
    if tool is None:
        raise Exception("No tool matching...")

    result = None

    if tool in self.tools:
        tool_obj = self.tools[tool]

        valid = tool_obj.validator(**kwargs)
        if valid:
            return tool_obj.function(**kwargs)
        else:
            return valid

    return result

fetch_metadata()

Fetch metadata for the local tool client.

Returns:

Type Description

An empty dictionary since no metadata is necessary for local tools.
Source code in blue/tools/clients/local_client.py 
65
66
67
68
69
70
71
def fetch_metadata(self):
    """Fetch metadata for the local tool client.

    Returns:
        An empty dictionary since no metadata is necessary for local tools.
    """
    return {}

fetch_tool_metadata(tool)

Fetch metadata for a specific tool on local client.

Parameters:

Name Type Description Default
tool

Name of the tool

 required

Returns:

Type Description

Metadata dictionary for the tool
Source code in blue/tools/clients/local_client.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def fetch_tool_metadata(self, tool):
    """Fetch metadata for a specific tool on local client.

    Parameters:
        tool: Name of the tool

    Returns:
        Metadata dictionary for the tool
    """
    metadata = {}

    if tool in self.tools:
        tool_obj = self.tools[tool]
        p = {}
        p = json_utils.merge_json(p, tool_obj.properties)
        p = json_utils.merge_json(p, {"signature": tool_obj.get_signature()})
        metadata = {"name": tool_obj.name, "description": tool_obj.description, "properties": p}
    return metadata

fetch_tools()

Get a list of available tools on local client.

Returns:

Type Description

List of tool names
Source code in blue/tools/clients/local_client.py 
74
75
76
77
78
79
80
81
def fetch_tools(self):
    """Get a list of available tools on local client.

    Returns:
        List of tool names
    """
    tools = list(self.tools.keys())
    return tools
Last update: 2025-10-07