veadk-python 0.1.0__py3-none-any.whl

veadk/tools/demo_tools.py

@@ -0,0 +1,58 @@
+# 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.
+
+
+def get_city_weather(city: str) -> dict[str, str]:
+    """Retrieves the weather information of a given city. the args must in English"""
+    fixed_weather = {
+        "beijing": {"condition": "Sunny", "temperature": 25},
+        "shanghai": {"condition": "Cloudy", "temperature": 22},
+        "guangzhou": {"condition": "Rainy", "temperature": 28},
+        "shenzhen": {"condition": "Partly cloudy", "temperature": 29},
+        "chengdu": {"condition": "Windy", "temperature": 20},
+        "hangzhou": {"condition": "Snowy", "temperature": -2},
+        "wuhan": {"condition": "Humid", "temperature": 26},
+        "chongqing": {"condition": "Hazy", "temperature": 30},
+        "xi'an": {"condition": "Cool", "temperature": 18},
+        "nanjing": {"condition": "Hot", "temperature": 32},
+    }
+
+    city = city.lower().strip()
+    if city in fixed_weather:
+        info = fixed_weather[city]
+        return {"result": f"{info['condition']}, {info['temperature']}°C"}
+    else:
+        return {"result": f"Weather information not found for {city}"}
+
+
+def get_location_weather(city: str) -> dict[str, str]:
+    """Retrieves the weather information of a given city. the args must in English"""
+    import random
+
+    condition = random.choice(
+        [
+            "Sunny",
+            "Cloudy",
+            "Rainy",
+            "Partly cloudy",
+            "Windy",
+            "Snowy",
+            "Humid",
+            "Hazy",
+            "Cool",
+            "Hot",
+        ]
+    )
+    temperature = random.randint(-10, 40)
+    return {"result": f"{condition}, {temperature}°C"}

veadk/tools/load_knowledgebase_tool.py

@@ -0,0 +1,144 @@
+# 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 __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import wrapt
+from google.adk.tools.function_tool import FunctionTool
+from google.adk.tools.tool_context import ToolContext
+from google.genai import types
+from pydantic import BaseModel, Field
+from typing_extensions import override
+
+from veadk.knowledgebase import KnowledgeBase
+
+if TYPE_CHECKING:
+    from google.adk.models import LlmRequest
+
+
+knowledgebase: KnowledgeBase | None = None
+
+
+class KnowledgebaseEntry(BaseModel):
+    content: str
+
+
+class LoadKnowledgebaseResponse(BaseModel):
+    knowledges: list[KnowledgebaseEntry] = Field(default_factory=list)
+
+
+class SearchKnowledgebaseResponse(BaseModel):
+    """Represents the response from a knowledgebase search.
+
+    Attributes:
+        knowledges: A list of knowledgebase entries that relate to the search query.
+    """
+
+    knowledges: list[KnowledgebaseEntry] = Field(default_factory=list)
+
+
+async def search_knowledgebase(
+    self, query: str, app_name: str, user_id: str
+) -> SearchKnowledgebaseResponse:
+    """Searches the knowledgebase of the current user."""
+    if isinstance(knowledgebase, KnowledgeBase):
+        res = knowledgebase.search(query, app_name=app_name, user_id=user_id)
+        entry_list = []
+        for r in res:
+            entry_list.append(KnowledgebaseEntry(content=r))
+        return SearchKnowledgebaseResponse(knowledges=entry_list)
+    else:
+        return SearchKnowledgebaseResponse(knowledges=[])
+
+
+@wrapt.when_imported("google.adk.tools.tool_context")
+def on_tool_context_imported(module):
+    class_ = getattr(module, "ToolContext", None)
+    if not class_:
+        raise ImportError("Could not find ToolContext in module")
+
+    if not hasattr(class_, "search_knowledgebase"):
+        class_.search_knowledgebase = search_knowledgebase
+
+
+async def load_knowledgebase(
+    query: str, tool_context: ToolContext
+) -> LoadKnowledgebaseResponse:
+    """Loads the knowledgebase for the user.
+
+    Args:
+      query: The query to load the knowledgebase for.
+
+    Returns:
+      A list of knowledgebase results.
+    """
+    search_knowledgebase_response = await tool_context.search_knowledgebase(
+        query,
+        tool_context._invocation_context.app_name,
+        tool_context._invocation_context.user_id,
+    )
+    return LoadKnowledgebaseResponse(
+        knowledges=search_knowledgebase_response.knowledges
+    )
+
+
+class LoadKnowledgebaseTool(FunctionTool):
+    """A tool that loads the common knowledgebase.
+
+    In the future, we will support multiple knowledgebase based on different user.
+    """
+
+    def __init__(self):
+        super().__init__(load_knowledgebase)
+
+    @override
+    def _get_declaration(self) -> types.FunctionDeclaration | None:
+        return types.FunctionDeclaration(
+            name=self.name,
+            description=self.description,
+            parameters=types.Schema(
+                type=types.Type.OBJECT,
+                properties={
+                    "query": types.Schema(
+                        type=types.Type.STRING,
+                    )
+                },
+                required=["query"],
+            ),
+        )
+
+    @override
+    async def process_llm_request(
+        self,
+        *,
+        tool_context: ToolContext,
+        llm_request: LlmRequest,
+    ) -> None:
+        await super().process_llm_request(
+            tool_context=tool_context, llm_request=llm_request
+        )
+        # Tell the model about the knowledgebase.
+        llm_request.append_instructions(
+            [
+                """
+You have a knowledgebase. You can use it to answer questions. If any questions need
+you to look up the knowledgebase, you should call load_knowledgebase function with a query.
+"""
+            ]
+        )
+
+
+load_knowledgebase_tool = LoadKnowledgebaseTool()

veadk/tools/sandbox/__init__.py

@@ -0,0 +1,13 @@
+# 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.

veadk/tools/sandbox/browser_sandbox.py

@@ -0,0 +1,27 @@
+# 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.
+
+browser_sandbox = ...
+
+
+def browser_use(prompt: str) -> str:
+    """Using the remote browser sandbox to according to the prompt.
+
+    Args:
+        prompt (str): The prompt to be used.
+
+    Returns:
+        str: The response from the sandbox.
+    """
+    ...

veadk/tools/sandbox/code_sandbox.py

@@ -0,0 +1,30 @@
+# 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.
+
+code_sandbox = ...
+
+
+def code_execution(code: str, language: str) -> str:
+    """Execute code in sandbox.
+
+    Args:
+        code (str): The code to be executed.
+        language (str): The language of the code.
+
+    Returns:
+        str: The response from the sandbox.
+    """
+
+    res = code_sandbox(code, language)
+    return res

veadk/tools/sandbox/computer_sandbox.py

@@ -0,0 +1,27 @@
+# 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.
+
+computer_sandbox = ...
+
+
+def computer_use(prompt: str) -> str:
+    """Using the remote computer sandbox to according to the prompt.
+
+    Args:
+        prompt (str): The prompt to be used.
+
+    Returns:
+        str: The response from the sandbox.
+    """
+    ...

veadk/tracing/__init__.py

@@ -0,0 +1,13 @@
+# 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.

veadk/tracing/base_tracer.py

@@ -0,0 +1,172 @@
+# 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 abc import ABC, abstractmethod
+from typing import Optional
+
+from google.adk.agents.callback_context import CallbackContext
+from google.adk.models import LlmRequest, LlmResponse
+from opentelemetry import trace
+
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseTracer(ABC):
+    def __init__(self, name: str):
+        pass
+
+    @abstractmethod
+    def dump(self) -> str: ...
+
+    def llm_metrics_hook(
+        self, callback_context: CallbackContext, llm_request: LlmRequest
+    ) -> Optional[LlmResponse]:
+        trace.get_tracer("gcp.vertex.agent")
+        span = trace.get_current_span()
+        # logger.debug(f"llm_request: {llm_request}")
+
+        req = llm_request.model_dump()
+
+        model_name = req.get("model", "unknown")
+        max_tokens = (
+            None
+            if not req.get("live_connect_config")
+            else req["live_connect_config"].get("max_output_tokens", None)
+        )
+        temperature = (
+            None
+            if not req.get("live_connect_config")
+            else req["live_connect_config"].get("temperature", None)
+        )
+        top_p = (
+            None
+            if not req.get("live_connect_config")
+            else req["live_connect_config"].get("top_p", None)
+        )
+
+        attributes = {}
+        attributes["gen_ai.system"] = "veadk"
+        if model_name:
+            attributes["gen_ai.request.model"] = model_name
+            attributes["gen_ai.response.model"] = (
+                model_name  # The req model and the resp model should be consistent.
+            )
+        attributes["gen_ai.request.type"] = "completion"
+        if max_tokens:
+            attributes["gen_ai.request.max_tokens"] = max_tokens
+        if temperature:
+            attributes["gen_ai.request.temperature"] = temperature
+        if top_p:
+            attributes["gen_ai.request.top_p"] = top_p
+
+        # Print attributes for debugging
+        # print("Tracing attributes:", attributes)
+
+        # Set all attributes at once if possible, else fallback to individual
+        if hasattr(span, "set_attributes"):
+            span.set_attributes(attributes)
+        else:
+            # Fallback for OpenTelemetry versions without set_attributes
+            for k, v in attributes.items():
+                span.set_attribute(k, v)
+
+    def token_metrics_hook(
+        self, callback_context: CallbackContext, llm_response: LlmResponse
+    ) -> Optional[LlmResponse]:
+        trace.get_tracer("gcp.vertex.agent")
+        span = trace.get_current_span()
+        # logger.debug(f"llm_response: {llm_response}")
+        # logger.debug(f"callback_context: {callback_context}")
+
+        # Refined: collect all attributes, use set_attributes, print for debugging
+        attributes = {}
+
+        # prompt
+        user_content = callback_context.user_content
+        if getattr(user_content, "role", None):
+            role = getattr(user_content, "role", None)
+        else:
+            role = None
+        if getattr(user_content, "parts", None):
+            content = callback_context.user_content.model_dump(exclude_none=True).get(
+                "parts", None
+            )
+            if content:
+                content = json.dumps(content)
+            else:
+                content = None
+        else:
+            content = None
+        if role and content:
+            attributes["gen_ai.prompt.0.role"] = role
+            attributes["gen_ai.prompt.0.content"] = content
+
+        # completion
+        completion_content = getattr(llm_response, "content").model_dump(
+            exclude_none=True
+        )
+        if completion_content:
+            content = json.dumps(
+                getattr(llm_response, "content").model_dump(exclude_none=True)["parts"]
+            )
+            role = getattr(llm_response, "content").model_dump(exclude_none=True)[
+                "role"
+            ]
+            if role and content:
+                attributes["gen_ai.completion.0.role"] = role
+                attributes["gen_ai.completion.0.content"] = content
+
+        if not llm_response.usage_metadata:
+            return
+
+        # tokens
+        metadata = llm_response.usage_metadata.model_dump()
+        if metadata:
+            prompt_tokens = metadata.get("prompt_token_count", None)
+            completion_tokens = metadata.get("candidates_token_count", None)
+            total_tokens = metadata.get("total_token_count", None)
+            cache_read_input_tokens = (
+                metadata.get("cache_read_input_tokens") or 0
+            )  # Might change, once openai introduces their equivalent.
+            cache_create_input_tokens = (
+                metadata.get("cache_create_input_tokens") or 0
+            )  # Might change, once openai introduces their equivalent.
+            if prompt_tokens:
+                attributes["gen_ai.usage.prompt_tokens"] = prompt_tokens
+            if completion_tokens:
+                attributes["gen_ai.usage.completion_tokens"] = completion_tokens
+            if total_tokens:
+                attributes["gen_ai.usage.total_tokens"] = total_tokens
+            if cache_read_input_tokens is not None:
+                attributes["gen_ai.usage.cache_read_input_tokens"] = (
+                    cache_read_input_tokens
+                )
+            if cache_create_input_tokens is not None:
+                attributes["gen_ai.usage.cache_create_input_tokens"] = (
+                    cache_create_input_tokens
+                )
+
+        # Print attributes for debugging
+        # print("Tracing attributes:", attributes)
+
+        # Set all attributes at once if possible, else fallback to individual
+        if hasattr(span, "set_attributes"):
+            span.set_attributes(attributes)
+        else:
+            # Fallback for OpenTelemetry versions without set_attributes
+            for k, v in attributes.items():
+                span.set_attribute(k, v)

veadk/tracing/telemetry/__init__.py

@@ -0,0 +1,13 @@
+# 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.

veadk/tracing/telemetry/exporters/__init__.py

@@ -0,0 +1,13 @@
+# 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.

veadk/tracing/telemetry/exporters/apiserver_exporter.py

@@ -0,0 +1,60 @@
+# 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 typing
+
+from opentelemetry.sdk.trace import ReadableSpan, export
+from pydantic import BaseModel
+from typing_extensions import override
+
+from veadk.tracing.telemetry.exporters.base_exporter import BaseExporter
+
+
+# ======== Adapted from Google ADK ========
+class _ApiServerSpanExporter(export.SpanExporter):
+    def __init__(self, trace_dict):
+        self.trace_dict = trace_dict
+        self.trace_id = ""
+
+    def export(self, spans: typing.Sequence[ReadableSpan]) -> export.SpanExportResult:
+        for span in spans:
+            if (
+                span.name == "call_llm"
+                or span.name == "send_data"
+                or span.name.startswith("execute_tool")
+            ):
+                attributes = dict(span.attributes)
+                attributes["trace_id"] = span.get_span_context().trace_id
+                attributes["span_id"] = span.get_span_context().span_id
+                if attributes.get("gcp.vertex.agent.event_id", None):
+                    self.trace_dict[attributes["gcp.vertex.agent.event_id"]] = (
+                        attributes
+                    )
+        return export.SpanExportResult.SUCCESS
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return True
+
+
+class ApiServerExporter(BaseModel, BaseExporter):
+    name: str = "apiserver_exporter"
+    trace_dict: dict = {}
+
+    def model_post_init(self, context) -> None:
+        self._exporter = _ApiServerSpanExporter(self.trace_dict)
+
+    @override
+    def get_processor(self):
+        processor = export.SimpleSpanProcessor(self._exporter)
+        return processor, None

veadk/tracing/telemetry/exporters/apmplus_exporter.py

@@ -0,0 +1,101 @@
+# 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 opentelemetry import metrics
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from pydantic import BaseModel, Field
+from typing_extensions import override
+
+from veadk.config import getenv
+from veadk.tracing.telemetry.exporters.base_exporter import BaseExporter
+from veadk.tracing.telemetry.metrics.opentelemetry_metrics import MeterContext
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class APMPlusExporterConfig(BaseModel):
+    endpoint: str = Field(
+        ...,
+        default_factory=lambda: getenv(
+            "OBSERVABILITY_OPENTELEMETRY_APMPLUS_ENDPOINT",
+            "http://apmplus-cn-beijing.volces.com:4317",
+        ),
+    )
+    app_key: str = Field(
+        ...,
+        default_factory=lambda: getenv("OBSERVABILITY_OPENTELEMETRY_APMPLUS_API_KEY"),
+    )
+    service_name: str = Field(
+        ...,
+        default_factory=lambda: getenv(
+            "OBSERVABILITY_OPENTELEMETRY_APMPLUS_SERVICE_NAME",
+            "veadk_tracing_service",
+        ),
+        description="Service name shown in APMPlus frontend.",
+    )
+
+
+class APMPlusExporter(BaseModel, BaseExporter):
+    config: APMPlusExporterConfig = Field(default_factory=APMPlusExporterConfig)
+
+    @override
+    def get_processor(self):
+        resource_attributes = {
+            "service.name": self.config.service_name,
+        }
+
+        headers = {
+            "x-byteapm-appkey": self.config.app_key,
+        }
+        exporter = OTLPSpanExporter(
+            endpoint=self.config.endpoint, insecure=True, headers=headers
+        )
+        self._real_exporter = exporter
+        processor = BatchSpanProcessor(exporter)
+        return processor, resource_attributes
+
+    def export(self):
+        self._real_exporter.force_flush()
+        logger.info(
+            f"APMPlusExporter exports data to {self.config.endpoint}, service name: {self.config.service_name}"
+        )
+
+    @override
+    def get_meter_context(self) -> MeterContext:
+        resource_attributes = {
+            "service.name": self.config.service_name,
+        }
+        endpoint = self.config.endpoint
+        headers = {
+            "x-byteapm-appkey": self.config.app_key,
+        }
+
+        resource = Resource.create(resource_attributes)
+        exporter = OTLPMetricExporter(endpoint=endpoint, headers=headers)
+        metric_reader = PeriodicExportingMetricReader(exporter)
+        provider = MeterProvider(metric_readers=[metric_reader], resource=resource)
+        metrics.set_meter_provider(provider)
+        meter = metrics.get_meter("my.meter.name")
+        meter_context = MeterContext(
+            meter=meter,
+            provider=provider,
+            reader=metric_reader,
+        )
+        return meter_context