Skip to content

vllm.entrypoints.tool

MIN_GPT_OSS_VERSION module-attribute 

MIN_GPT_OSS_VERSION = '0.0.7'

logger module-attribute 

logger = init_logger(__name__)

HarmonyBrowserTool

Bases: Tool

Source code in vllm/entrypoints/tool.py 
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
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

    async def get_result_parsable_context(self, context: "ConversationContext") -> Any:
        raise NotImplementedError("Not implemented yet")

    @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 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
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 
83
84
85
86
87
88
89
90
91
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

get_result_parsable_context async 

get_result_parsable_context(
    context: ConversationContext,
) -> Any
Source code in vllm/entrypoints/tool.py 
93
94
async def get_result_parsable_context(self, context: "ConversationContext") -> Any:
    raise NotImplementedError("Not implemented yet")

HarmonyPythonTool

Bases: Tool

Source code in vllm/entrypoints/tool.py 
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
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

    async def get_result_parsable_context(self, context: "ConversationContext") -> Any:
        """
        This function converts parsable context types to harmony and
        back so we can use GPTOSS demo python tool
        """
        from vllm.entrypoints.context import ParsableContext

        assert isinstance(context, ParsableContext)

        last_msg = context.parser.response_messages[-1]
        args = json.loads(last_msg.arguments)

        last_msg_harmony = Message(
            author=Author(role="assistant", name=None),
            content=[TextContent(text=args["code"])],
            channel="analysis",
            recipient="python",
            content_type="code",
        )

        tool_output_msgs = []
        async for msg in self.python_tool.process(last_msg_harmony):
            processed = ResponseFunctionToolCallOutputItem(
                id=f"fco_{random_uuid()}",
                type="function_call_output",
                call_id=f"call_{random_uuid()}",
                output=msg.content[0].text,
                status="completed",
            )
            tool_output_msgs.append(processed)
        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 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
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 
143
144
145
146
147
148
149
150
151
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

get_result_parsable_context async 

get_result_parsable_context(
    context: ConversationContext,
) -> Any

This function converts parsable context types to harmony and back so we can use GPTOSS demo python tool

Source code in vllm/entrypoints/tool.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
async def get_result_parsable_context(self, context: "ConversationContext") -> Any:
    """
    This function converts parsable context types to harmony and
    back so we can use GPTOSS demo python tool
    """
    from vllm.entrypoints.context import ParsableContext

    assert isinstance(context, ParsableContext)

    last_msg = context.parser.response_messages[-1]
    args = json.loads(last_msg.arguments)

    last_msg_harmony = Message(
        author=Author(role="assistant", name=None),
        content=[TextContent(text=args["code"])],
        channel="analysis",
        recipient="python",
        content_type="code",
    )

    tool_output_msgs = []
    async for msg in self.python_tool.process(last_msg_harmony):
        processed = ResponseFunctionToolCallOutputItem(
            id=f"fco_{random_uuid()}",
            type="function_call_output",
            call_id=f"call_{random_uuid()}",
            output=msg.content[0].text,
            status="completed",
        )
        tool_output_msgs.append(processed)
    return tool_output_msgs

validate async 

validate()
Source code in vllm/entrypoints/tool.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
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 
49
50
51
52
53
54
55
56
class Tool(ABC):
    @abstractmethod
    async def get_result(self, context: "ConversationContext") -> Any:
        pass

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

get_result abstractmethod async 

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

get_result_parsable_context abstractmethod async 

get_result_parsable_context(
    context: ConversationContext,
) -> Any
Source code in vllm/entrypoints/tool.py 
54
55
56
@abstractmethod
async def get_result_parsable_context(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.7. If not, raise an ImportError.

Source code in vllm/entrypoints/tool.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
def validate_gpt_oss_install():
    """
    Check if the gpt-oss is installed and its version is at least 0.0.7.
    If not, raise an ImportError.
    """
    from importlib.metadata import PackageNotFoundError, version

    from packaging.version import InvalidVersion, Version

    try:
        pkg_version_str = version("gpt_oss")
        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(MIN_GPT_OSS_VERSION):
        raise ImportError(
            f"gpt_oss >= {MIN_GPT_OSS_VERSION} is required, "
            f"but {pkg_version} is installed."
        ) from None