Skip to content

vllm.entrypoints.tool

logger module-attribute 

logger = init_logger(__name__)

HarmonyBrowserTool

Bases: Tool

Source code in vllm/entrypoints/tool.py 
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
class HarmonyBrowserTool(Tool):

    def __init__(self):
        self.enabled = True
        exa_api_key = os.getenv("EXA_API_KEY")
        if not exa_api_key:
            self.enabled = False
            logger.warning_once("EXA_API_KEY is not set, browsing is disabled")
            return

        try:
            validate_gpt_oss_install()
            from gpt_oss.tools.simple_browser import SimpleBrowserTool
            from gpt_oss.tools.simple_browser.backend import ExaBackend
        except ImportError as e:
            self.enabled = False
            logger.warning_once(
                "gpt_oss is not installed properly (%s), browsing is disabled",
                e)
            return

        browser_backend = ExaBackend(source="web", api_key=exa_api_key)
        self.browser_tool = SimpleBrowserTool(backend=browser_backend)
        logger.info_once("Browser tool initialized")

    async def get_result(self, context: "ConversationContext") -> Any:
        from vllm.entrypoints.context import HarmonyContext
        assert isinstance(context, HarmonyContext)
        last_msg = context.messages[-1]
        tool_output_msgs = []
        async for msg in self.browser_tool.process(last_msg):
            tool_output_msgs.append(msg)
        return tool_output_msgs

    @property
    def tool_config(self) -> Any:
        return self.browser_tool.tool_config

browser_tool instance-attribute 

browser_tool = SimpleBrowserTool(backend=browser_backend)

enabled instance-attribute 

enabled = True

tool_config property 

tool_config: Any

__init__ 

__init__()
Source code in vllm/entrypoints/tool.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
def __init__(self):
    self.enabled = True
    exa_api_key = os.getenv("EXA_API_KEY")
    if not exa_api_key:
        self.enabled = False
        logger.warning_once("EXA_API_KEY is not set, browsing is disabled")
        return

    try:
        validate_gpt_oss_install()
        from gpt_oss.tools.simple_browser import SimpleBrowserTool
        from gpt_oss.tools.simple_browser.backend import ExaBackend
    except ImportError as e:
        self.enabled = False
        logger.warning_once(
            "gpt_oss is not installed properly (%s), browsing is disabled",
            e)
        return

    browser_backend = ExaBackend(source="web", api_key=exa_api_key)
    self.browser_tool = SimpleBrowserTool(backend=browser_backend)
    logger.info_once("Browser tool initialized")

get_result async 

get_result(context: ConversationContext) -> Any
Source code in vllm/entrypoints/tool.py 
74
75
76
77
78
79
80
81
async def get_result(self, context: "ConversationContext") -> Any:
    from vllm.entrypoints.context import HarmonyContext
    assert isinstance(context, HarmonyContext)
    last_msg = context.messages[-1]
    tool_output_msgs = []
    async for msg in self.browser_tool.process(last_msg):
        tool_output_msgs.append(msg)
    return tool_output_msgs

HarmonyPythonTool

Bases: Tool

Source code in vllm/entrypoints/tool.py 
 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
class HarmonyPythonTool(Tool):

    def __init__(self):
        self.enabled = True

        try:
            validate_gpt_oss_install()
            from gpt_oss.tools.python_docker.docker_tool import PythonTool
        except ImportError as e:
            self.enabled = False
            logger.warning_once(
                "gpt_oss is not installed properly (%s), code interpreter is "
                "disabled", e)
            return

        self.python_tool = PythonTool()

    async def validate(self):
        if not self.enabled:
            return
        try:
            message = Message(
                author=Author(role=Role.ASSISTANT),
                content=[TextContent(text="print('Hello, world!')")],
                channel="analysis",
                recipient="python",
                content_type="code",
            )
            msgs = []
            async for msg in self.python_tool.process(message):
                msgs.append(msg)
            assert msgs[0].content[0].text == "Hello, world!\n"
        except Exception as e:
            self.enabled = False
            logger.warning_once(
                "Code interpreter tool failed to initialize (%s), code "
                "interpreter is disabled", e)
            return
        logger.info_once("Code interpreter tool initialized")

    async def get_result(self, context: "ConversationContext") -> Any:
        from vllm.entrypoints.context import HarmonyContext
        assert isinstance(context, HarmonyContext)
        last_msg = context.messages[-1]
        tool_output_msgs = []
        async for msg in self.python_tool.process(last_msg):
            tool_output_msgs.append(msg)
        return tool_output_msgs

    @property
    def tool_config(self) -> Any:
        return self.python_tool.tool_config

enabled instance-attribute 

enabled = True

python_tool instance-attribute 

python_tool = PythonTool()

tool_config property 

tool_config: Any

__init__ 

__init__()
Source code in vllm/entrypoints/tool.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def __init__(self):
    self.enabled = True

    try:
        validate_gpt_oss_install()
        from gpt_oss.tools.python_docker.docker_tool import PythonTool
    except ImportError as e:
        self.enabled = False
        logger.warning_once(
            "gpt_oss is not installed properly (%s), code interpreter is "
            "disabled", e)
        return

    self.python_tool = PythonTool()

get_result async 

get_result(context: ConversationContext) -> Any
Source code in vllm/entrypoints/tool.py 
128
129
130
131
132
133
134
135
async def get_result(self, context: "ConversationContext") -> Any:
    from vllm.entrypoints.context import HarmonyContext
    assert isinstance(context, HarmonyContext)
    last_msg = context.messages[-1]
    tool_output_msgs = []
    async for msg in self.python_tool.process(last_msg):
        tool_output_msgs.append(msg)
    return tool_output_msgs

validate async 

validate()
Source code in vllm/entrypoints/tool.py 
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
async def validate(self):
    if not self.enabled:
        return
    try:
        message = Message(
            author=Author(role=Role.ASSISTANT),
            content=[TextContent(text="print('Hello, world!')")],
            channel="analysis",
            recipient="python",
            content_type="code",
        )
        msgs = []
        async for msg in self.python_tool.process(message):
            msgs.append(msg)
        assert msgs[0].content[0].text == "Hello, world!\n"
    except Exception as e:
        self.enabled = False
        logger.warning_once(
            "Code interpreter tool failed to initialize (%s), code "
            "interpreter is disabled", e)
        return
    logger.info_once("Code interpreter tool initialized")

Tool

Bases: ABC

Source code in vllm/entrypoints/tool.py 
42
43
44
45
46
class Tool(ABC):

    @abstractmethod
    async def get_result(self, context: "ConversationContext") -> Any:
        pass

get_result abstractmethod async 

get_result(context: ConversationContext) -> Any
Source code in vllm/entrypoints/tool.py 
44
45
46
@abstractmethod
async def get_result(self, context: "ConversationContext") -> Any:
    pass

validate_gpt_oss_install 

validate_gpt_oss_install()

Check if the gpt-oss is installed and its version is at least 0.0.3. If not, raise an ImportError.

Source code in vllm/entrypoints/tool.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def validate_gpt_oss_install():
    """
    Check if the gpt-oss is installed and its version is at least 0.0.3.
    If not, raise an ImportError.
    """
    from importlib.metadata import PackageNotFoundError, version

    from packaging.version import InvalidVersion, Version

    try:
        pkg_version_str = version("gpt_oss")  # e.g., "0.0.5"
        pkg_version = Version(pkg_version_str)
    except PackageNotFoundError:
        raise ImportError("Package 'gpt_oss' is not installed.") from None
    except InvalidVersion as e:
        raise ImportError(
            f"Invalid version string for 'gpt_oss': {e}") from None

    if pkg_version < Version("0.0.3"):
        raise ImportError(
            f"gpt_oss >= 0.0.3 is required, but {pkg_version} is installed."
        ) from None