veadk-python 0.2.2__py3-none-any.whl → 0.2.5__py3-none-any.whl

veadk/tracing/telemetry/attributes/extractors/common_attributes_extractors.py

@@ -0,0 +1,71 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from veadk.version import VERSION
+
+
+def common_gen_ai_system(**kwargs) -> str:
+    """This field will be parsed as `model_provider` in Volcengine CozeLoop platform."""
+    model_provider = kwargs.get("model_provider")
+    return model_provider or "<unknown_model_provider>"
+
+
+def common_gen_ai_system_version(**kwargs) -> str:
+    return VERSION
+
+
+def common_gen_ai_app_name(**kwargs) -> str:
+    app_name = kwargs.get("app_name")
+    return app_name or "<unknown_app_name>"
+
+
+def common_gen_ai_agent_name(**kwargs) -> str:
+    agent_name = kwargs.get("agent_name")
+    return agent_name or "<unknown_agent_name>"
+
+
+def common_gen_ai_user_id(**kwargs) -> str:
+    user_id = kwargs.get("user_id")
+    return user_id or "<unknown_user_id>"
+
+
+def common_gen_ai_session_id(**kwargs) -> str:
+    session_id = kwargs.get("session_id")
+    return session_id or "<unknown_session_id>"
+
+
+def common_cozeloop_report_source(**kwargs) -> str:
+    return "veadk"
+
+
+def llm_openinference_instrumentation_veadk(**kwargs) -> str:
+    return VERSION
+
+
+COMMON_ATTRIBUTES = {
+    "gen_ai.system": common_gen_ai_system,
+    "gen_ai.system.version": common_gen_ai_system_version,
+    "gen_ai.agent.name": common_gen_ai_agent_name,
+    "openinference.instrumentation.veadk": llm_openinference_instrumentation_veadk,
+    "gen_ai.app.name": common_gen_ai_app_name,  # APMPlus required
+    "gen_ai.user.id": common_gen_ai_user_id,  # APMPlus required
+    "gen_ai.session.id": common_gen_ai_session_id,  # APMPlus required
+    "agent_name": common_gen_ai_agent_name,  # CozeLoop required
+    "agent.name": common_gen_ai_agent_name,  # TLS required
+    "app_name": common_gen_ai_app_name,  # CozeLoop required
+    "app.name": common_gen_ai_app_name,  # TLS required
+    "user.id": common_gen_ai_user_id,  # CozeLoop / TLS required
+    "session.id": common_gen_ai_session_id,  # CozeLoop / TLS required
+    "cozeloop.report.source": common_cozeloop_report_source,  # CozeLoop required
+}

veadk/tracing/telemetry/attributes/extractors/llm_attributes_extractors.py

@@ -0,0 +1,451 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+
+from veadk.tracing.telemetry.attributes.extractors.types import (
+    ExtractorResponse,
+    LLMAttributesParams,
+)
+from veadk.utils.misc import safe_json_serialize
+
+
+def llm_gen_ai_request_model(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content=params.llm_request.model or "<unknown_model_name>")
+
+
+def llm_gen_ai_request_type(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="chat" or "<unknown_type>")
+
+
+def llm_gen_ai_response_model(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content=params.llm_request.model or "<unknown_model_name>")
+
+
+def llm_gen_ai_request_max_tokens(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content=params.llm_request.config.max_output_tokens)
+
+
+def llm_gen_ai_request_temperature(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content=params.llm_request.config.temperature)
+
+
+def llm_gen_ai_request_top_p(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content=params.llm_request.config.top_p)
+
+
+def llm_gen_ai_response_stop_reason(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="<no_stop_reason_provided>")
+
+
+def llm_gen_ai_response_finish_reason(params: LLMAttributesParams) -> ExtractorResponse:
+    # TODO: update to google-adk v1.12.0
+    return ExtractorResponse(content="<no_finish_reason_provided>")
+
+
+def llm_gen_ai_usage_input_tokens(params: LLMAttributesParams) -> ExtractorResponse:
+    if params.llm_response.usage_metadata:
+        return ExtractorResponse(
+            content=params.llm_response.usage_metadata.prompt_token_count
+        )
+    return ExtractorResponse(content=None)
+
+
+def llm_gen_ai_usage_output_tokens(params: LLMAttributesParams) -> ExtractorResponse:
+    if params.llm_response.usage_metadata:
+        return ExtractorResponse(
+            content=params.llm_response.usage_metadata.candidates_token_count,
+        )
+    return ExtractorResponse(content=None)
+
+
+def llm_gen_ai_usage_total_tokens(params: LLMAttributesParams) -> ExtractorResponse:
+    if params.llm_response.usage_metadata:
+        return ExtractorResponse(
+            content=params.llm_response.usage_metadata.total_token_count,
+        )
+    return ExtractorResponse(content=None)
+
+
+# FIXME
+def llm_gen_ai_usage_cache_creation_input_tokens(
+    params: LLMAttributesParams,
+) -> ExtractorResponse:
+    if params.llm_response.usage_metadata:
+        return ExtractorResponse(
+            content=params.llm_response.usage_metadata.cached_content_token_count,
+        )
+    return ExtractorResponse(content=None)
+
+
+# FIXME
+def llm_gen_ai_usage_cache_read_input_tokens(
+    params: LLMAttributesParams,
+) -> ExtractorResponse:
+    if params.llm_response.usage_metadata:
+        return ExtractorResponse(
+            content=params.llm_response.usage_metadata.cached_content_token_count,
+        )
+    return ExtractorResponse(content=None)
+
+
+def llm_gen_ai_prompt(params: LLMAttributesParams) -> ExtractorResponse:
+    # a part is a message
+    messages: list[dict] = []
+    idx = 0
+
+    for content in params.llm_request.contents:
+        if content.parts:
+            for part in content.parts:
+                message = {}
+                # text part
+                if part.text:
+                    message[f"gen_ai.prompt.{idx}.role"] = content.role
+                    message[f"gen_ai.prompt.{idx}.content"] = part.text
+                # function response
+                if part.function_response:
+                    message[f"gen_ai.prompt.{idx}.role"] = content.role
+                    message[f"gen_ai.prompt.{idx}.content"] = (
+                        str(part.function_response.response)
+                        if part.function_response
+                        else "<unknown_function_response>"
+                    )
+                # function call
+                if part.function_call:
+                    message[f"gen_ai.prompt.{idx}.tool_calls.0.id"] = (
+                        part.function_call.id
+                        if part.function_call.id
+                        else "<unkown_function_call_id>"
+                    )
+                    message[f"gen_ai.prompt.{idx}.tool_calls.0.type"] = "function"
+                    message[f"gen_ai.prompt.{idx}.tool_calls.0.function.name"] = (
+                        part.function_call.name
+                        if part.function_call.name
+                        else "<unknown_function_name>"
+                    )
+                    message[f"gen_ai.prompt.{idx}.tool_calls.0.function.arguments"] = (
+                        safe_json_serialize(part.function_call.args)
+                        if part.function_call.args
+                        else json.dumps({})
+                    )
+                # image
+                if part.inline_data:
+                    message[f"gen_ai.prompt.{idx}.type"] = "image_url"
+                    message[f"gen_ai.prompt.{idx}.image_url.name"] = (
+                        part.inline_data.display_name.split("/")[-1]
+                    )
+                    message[f"gen_ai.prompt.{idx}.image_url.url"] = (
+                        part.inline_data.display_name
+                    )
+
+                if message:
+                    messages.append(message)
+                    idx += 1
+
+    return ExtractorResponse(content=messages)
+
+
+def llm_gen_ai_completion(params: LLMAttributesParams) -> ExtractorResponse:
+    messages = []
+
+    content = params.llm_response.content
+    if content and content.parts:
+        for idx, part in enumerate(content.parts):
+            message = {}
+            if part.text:
+                message[f"gen_ai.completion.{idx}.role"] = content.role
+                message[f"gen_ai.completion.{idx}.content"] = part.text
+            elif part.function_call:
+                message[f"gen_ai.completion.{idx}.role"] = content.role
+                message[f"gen_ai.completion.{idx}.tool_calls.0.id"] = (
+                    part.function_call.id
+                    if part.function_call.id
+                    else "<unkown_function_call_id>"
+                )
+                message[f"gen_ai.completion.{idx}.tool_calls.0.type"] = "function"
+                message[f"gen_ai.completion.{idx}.tool_calls.0.function.name"] = (
+                    part.function_call.name
+                    if part.function_call.name
+                    else "<unknown_function_name>"
+                )
+                message[f"gen_ai.completion.{idx}.tool_calls.0.function.arguments"] = (
+                    safe_json_serialize(part.function_call.args)
+                    if part.function_call.args
+                    else json.dumps({})
+                )
+
+            if message:
+                messages.append(message)
+    return ExtractorResponse(content=messages)
+
+
+def llm_gen_ai_is_streaming(params: LLMAttributesParams) -> ExtractorResponse:
+    # return params.llm_request.stream
+    return ExtractorResponse(content=None)
+
+
+def llm_gen_ai_operation_name(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="chat")
+
+
+def llm_gen_ai_system_message(params: LLMAttributesParams) -> ExtractorResponse:
+    event_attributes = {
+        "content": str(params.llm_request.config.system_instruction),
+        "role": "system",
+    }
+    return ExtractorResponse(type="event", content=event_attributes)
+
+
+def llm_gen_ai_user_message(params: LLMAttributesParams) -> ExtractorResponse:
+    # a content is a message
+    messages = []
+
+    for content in params.llm_request.contents:
+        if content.role == "user":
+            message_parts = []
+
+            if content.parts:
+                if len(content.parts) == 1:
+                    if content.parts[0].text:
+                        message_parts.append(
+                            {
+                                "role": content.role,
+                                "content": content.parts[0].text,
+                            }
+                        )
+                    elif content.parts[0].function_response:
+                        message_parts.append(
+                            {
+                                "role": content.role,
+                                "content": str(
+                                    content.parts[0].function_response.response
+                                ),
+                            }
+                        )
+                else:
+                    message_part = {"role": content.role}
+                    for idx, part in enumerate(content.parts):
+                        # text part
+                        if part.text:
+                            message_part[f"parts.{idx}.type"] = "text"
+                            message_part[f"parts.{idx}.content"] = part.text
+                        # function response
+                        if part.function_response:
+                            message_part[f"parts.{idx}.type"] = "function"
+                            message_part[f"parts.{idx}.content"] = str(
+                                part.function_response
+                            )
+                        if part.inline_data:
+                            message_part[f"parts.{idx}.type"] = "image_url"
+                            message_part[f"parts.{idx}.image_url.name"] = (
+                                part.inline_data.display_name.split("/")[-1]
+                            )
+                            message_part[f"parts.{idx}.image_url.url"] = (
+                                part.inline_data.display_name
+                            )
+
+                    message_parts.append(message_part)
+
+            if message_parts:
+                messages.extend(message_parts)
+
+    return ExtractorResponse(type="event", content=messages)
+
+
+def llm_gen_ai_assistant_message(params: LLMAttributesParams) -> ExtractorResponse:
+    # a content is a message
+    messages = []
+
+    # each part in each content we make it a message
+    # e.g. 2 contents and 3 parts each means 6 messages
+    for content in params.llm_request.contents:
+        if content.role == "model":
+            message_parts = []
+
+            # each part we make it a message
+            if content.parts:
+                # only one part
+                if len(content.parts) == 1:
+                    if content.parts[0].text:
+                        message_parts.append(
+                            {
+                                "role": content.role,
+                                "content": content.parts[0].text,
+                            }
+                        )
+                    elif content.parts[0].function_call:
+                        pass
+                # multiple parts
+                else:
+                    message_part = {"role": content.role}
+
+                    for idx, part in enumerate(content.parts):
+                        # parse content
+                        if part.text:
+                            message_part[f"parts.{idx}.type"] = "text"
+                            message_part[f"parts.{idx}.content"] = part.text
+                        # parse tool_calls
+                        if part.function_call:
+                            message_part["tool_calls.0.id"] = (
+                                part.function_call.id
+                                if part.function_call.id
+                                else "<unkown_function_call_id>"
+                            )
+                            message_part["tool_calls.0.type"] = "function"
+                            message_part["tool_calls.0.function.name"] = (
+                                part.function_call.name
+                                if part.function_call.name
+                                else "<unknown_function_name>"
+                            )
+                            message_part["tool_calls.0.function.arguments"] = (
+                                safe_json_serialize(part.function_call.args)
+                                if part.function_call.args
+                                else json.dumps({})
+                            )
+                    message_parts.append(message_part)
+
+            if message_parts:
+                messages.extend(message_parts)
+
+    return ExtractorResponse(type="event", content=messages)
+
+
+def llm_gen_ai_choice(params: LLMAttributesParams) -> ExtractorResponse:
+    message = {}
+
+    # parse content to build a message
+    content = params.llm_response.content
+    if content and content.parts:
+        message = {"message.role": content.role}
+
+        if len(content.parts) == 1:
+            part = content.parts[0]
+            if part.text:
+                message["message.content"] = part.text
+            elif part.function_call:
+                message["message.tool_calls.0.id"] = (
+                    part.function_call.id
+                    if part.function_call.id
+                    else "<unkown_function_call_id>"
+                )
+                message["message.tool_calls.0.type"] = "function"
+                message["message.tool_calls.0.function.name"] = (
+                    part.function_call.name
+                    if part.function_call.name
+                    else "<unknown_function_name>"
+                )
+                message["message.tool_calls.0.function.arguments"] = (
+                    safe_json_serialize(part.function_call.args)
+                    if part.function_call.args
+                    else json.dumps({})
+                )
+        else:
+            for idx, part in enumerate(content.parts):
+                # parse content
+                if part.text:
+                    message[f"message.parts.{idx}.type"] = "text"
+                    message[f"message.parts.{idx}.text"] = part.text
+
+                # parse tool_calls
+                if part.function_call:
+                    message["message.tool_calls.0.id"] = (
+                        part.function_call.id
+                        if part.function_call.id
+                        else "<unkown_function_call_id>"
+                    )
+                    message["message.tool_calls.0.type"] = "function"
+                    message["message.tool_calls.0.function.name"] = (
+                        part.function_call.name
+                        if part.function_call.name
+                        else "<unknown_function_name>"
+                    )
+                    message["message.tool_calls.0.function.arguments"] = (
+                        safe_json_serialize(part.function_call.args)
+                        if part.function_call.args
+                        else json.dumps({})
+                    )
+
+    return ExtractorResponse(type="event", content=message)
+
+
+def llm_input_value(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(
+        content=str(params.llm_request.model_dump(exclude_none=True))
+    )
+
+
+def llm_output_value(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(
+        content=str(params.llm_response.model_dump(exclude_none=True))
+    )
+
+
+def llm_gen_ai_request_functions(params: LLMAttributesParams) -> ExtractorResponse:
+    functions = []
+
+    for idx, (tool_name, tool_instance) in enumerate(
+        params.llm_request.tools_dict.items()
+    ):
+        functions.append(
+            {
+                f"gen_ai.request.functions.{idx}.name": tool_instance.name,
+                f"gen_ai.request.functions.{idx}.description": tool_instance.description,
+                f"gen_ai.request.functions.{idx}.parameters": str(
+                    tool_instance._get_declaration().parameters.model_dump(  # type: ignore
+                        exclude_none=True
+                    )
+                    if tool_instance._get_declaration()
+                    and tool_instance._get_declaration().parameters  # type: ignore
+                    else {}
+                ),
+            }
+        )
+
+    return ExtractorResponse(content=functions)
+
+
+LLM_ATTRIBUTES = {
+    # ===== request attributes =====
+    "gen_ai.request.model": llm_gen_ai_request_model,
+    "gen_ai.request.type": llm_gen_ai_request_type,
+    "gen_ai.request.max_tokens": llm_gen_ai_request_max_tokens,
+    "gen_ai.request.temperature": llm_gen_ai_request_temperature,
+    "gen_ai.request.top_p": llm_gen_ai_request_top_p,
+    "gen_ai.request.functions": llm_gen_ai_request_functions,
+    # ===== response attributes =====
+    "gen_ai.response.model": llm_gen_ai_response_model,
+    "gen_ai.response.stop_reason": llm_gen_ai_response_stop_reason,
+    "gen_ai.response.finish_reason": llm_gen_ai_response_finish_reason,
+    # ===== streaming =====
+    "gen_ai.is_streaming": llm_gen_ai_is_streaming,
+    # ===== span type =====
+    "gen_ai.operation.name": llm_gen_ai_operation_name,
+    # ===== inputs and outputs =====
+    # events
+    "gen_ai.system.message": llm_gen_ai_system_message,
+    "gen_ai.user.message": llm_gen_ai_user_message,
+    "gen_ai.assistant.message": llm_gen_ai_assistant_message,
+    "gen_ai.choice": llm_gen_ai_choice,
+    # attributes
+    "gen_ai.prompt": llm_gen_ai_prompt,
+    "gen_ai.completion": llm_gen_ai_completion,
+    # "input.value": llm_input_value,
+    # "output.value": llm_output_value,
+    # ===== usage =====
+    "gen_ai.usage.input_tokens": llm_gen_ai_usage_input_tokens,
+    "gen_ai.usage.output_tokens": llm_gen_ai_usage_output_tokens,
+    "gen_ai.usage.total_tokens": llm_gen_ai_usage_total_tokens,
+    "gen_ai.usage.cache_creation_input_tokens": llm_gen_ai_usage_cache_creation_input_tokens,
+    "gen_ai.usage.cache_read_input_tokens": llm_gen_ai_usage_cache_read_input_tokens,
+}

veadk/tracing/telemetry/attributes/extractors/tool_attributes_extractors.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from veadk.tracing.telemetry.attributes.extractors.types import (
+    ExtractorResponse,
+    ToolAttributesParams,
+)
+from veadk.utils.misc import safe_json_serialize
+
+
+def tool_gen_ai_operation_name(params: ToolAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="execute_tool")
+
+
+def tool_gen_ai_tool_message(params: ToolAttributesParams) -> ExtractorResponse:
+    tool_input = {
+        "role": "tool",
+        "content": safe_json_serialize(
+            {
+                "name": params.tool.name,
+                "description": params.tool.description,
+                "parameters": params.args,
+            }
+        ),
+    }
+    return ExtractorResponse(type="event", content=tool_input)
+
+
+def tool_gen_ai_tool_input(params: ToolAttributesParams) -> ExtractorResponse:
+    tool_input = {
+        "name": params.tool.name,
+        "description": params.tool.description,
+        "parameters": params.args,
+    }
+    return ExtractorResponse(
+        content=safe_json_serialize(tool_input) or "<unknown_tool_input>"
+    )
+
+
+def tool_gen_ai_tool_name(params: ToolAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content=params.tool.name or "<unknown_tool_name>")
+
+
+def tool_gen_ai_tool_output(params: ToolAttributesParams) -> ExtractorResponse:
+    function_response = params.function_response_event.get_function_responses()[
+        0
+    ].model_dump()
+    tool_output = {
+        "id": function_response["id"],
+        "name": function_response["name"],
+        "response": function_response["response"],
+    }
+    return ExtractorResponse(
+        content=safe_json_serialize(tool_output) or "<unknown_tool_output>"
+    )
+
+
+TOOL_ATTRIBUTES = {
+    "gen_ai.operation.name": tool_gen_ai_operation_name,
+    "gen_ai.tool.name": tool_gen_ai_tool_name,  # TLS required
+    "gen_ai.tool.input": tool_gen_ai_tool_input,  # TLS required
+    "gen_ai.tool.output": tool_gen_ai_tool_output,  # TLS required
+    "cozeloop.input": tool_gen_ai_tool_input,  # CozeLoop required
+    "cozeloop.output": tool_gen_ai_tool_output,  # CozeLoop required
+}

veadk/tracing/telemetry/attributes/extractors/types.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Literal
+
+from attr import dataclass
+from google.adk.agents.invocation_context import InvocationContext
+from google.adk.events import Event
+from google.adk.models.llm_request import LlmRequest
+from google.adk.models.llm_response import LlmResponse
+from google.adk.tools import BaseTool
+from opentelemetry.sdk.trace import _Span
+from opentelemetry.trace.span import Span
+
+
+@dataclass
+class ExtractorResponse:
+    content: list | dict | None | str | int | float
+
+    type: Literal["attribute", "event"] = "attribute"
+    """Type of extractor response.
+    
+    `attribute`: span.add_attribute(attr_name, attr_value)
+    `event`: span.add_event(...)
+    """
+
+    @staticmethod
+    def update_span(
+        span: _Span | Span, attr_name: str, response: "ExtractorResponse"
+    ) -> None:
+        if response.type == "attribute":
+            res = response.content
+            if isinstance(res, list):  # list[dict]
+                for _res in res:
+                    if isinstance(_res, dict):
+                        for k, v in _res.items():
+                            span.set_attribute(k, v)
+            else:
+                # set anyway
+                span.set_attribute(attr_name, res)  # type: ignore
+        elif response.type == "event":
+            if isinstance(response.content, dict):
+                span.add_event(attr_name, response.content)
+            elif isinstance(response.content, list):
+                for event in response.content:
+                    span.add_event(attr_name, event)
+        else:
+            # Unsupported response type, discard it.
+            pass
+
+
+@dataclass
+class LLMAttributesParams:
+    invocation_context: InvocationContext
+    event_id: str
+    llm_request: LlmRequest
+    llm_response: LlmResponse
+
+
+@dataclass
+class ToolAttributesParams:
+    tool: BaseTool
+    args: dict[str, Any]
+    function_response_event: Event