veadk-python 0.2.9__py3-none-any.whl → 0.2.10__py3-none-any.whl

veadk/memory/short_term_memory.py

@@ -19,6 +19,7 @@ from google.adk.sessions import (
     BaseSessionService,
     DatabaseSessionService,
     InMemorySessionService,
+    Session,
 )
 from pydantic import BaseModel, Field, PrivateAttr
 
@@ -106,7 +107,7 @@ class ShortTermMemory(BaseModel):
         app_name: str,
         user_id: str,
         session_id: str,
-    ) -> None:
+    ) -> Session | None:
         if isinstance(self._session_service, DatabaseSessionService):
             list_sessions_response = await self._session_service.list_sessions(
                 app_name=app_name, user_id=user_id
@@ -122,7 +123,12 @@ class ShortTermMemory(BaseModel):
             )
             is None
         ):
-            # create a new session for this running
-            await self._session_service.create_session(
+            return await self._session_service.create_session(
                 app_name=app_name, user_id=user_id, session_id=session_id
             )
+        else:
+            logger.info(
+                f"Session {session_id} already exists with app_name={app_name} user_id={user_id}."
+            )
+
+            return None

veadk/memory/short_term_memory_backends/postgresql_backend.py

@@ -14,6 +14,7 @@
 
 from functools import cached_property
 from typing import Any
+from venv import logger
 
 from google.adk.sessions import (
     BaseSessionService,
@@ -33,7 +34,8 @@ class PostgreSqlSTMBackend(BaseShortTermMemoryBackend):
     postgresql_config: PostgreSqlConfig = Field(default_factory=PostgreSqlConfig)
 
     def model_post_init(self, context: Any) -> None:
-        self._db_url = f"postgresql+psycopg2://{self.postgresql_config.user}:{self.postgresql_config.password}@{self.postgresql_config.host}:{self.postgresql_config.port}/{self.postgresql_config.database}"
+        self._db_url = f"postgresql://{self.postgresql_config.user}:{self.postgresql_config.password}@{self.postgresql_config.host}:{self.postgresql_config.port}/{self.postgresql_config.database}"
+        logger.debug(self._db_url)
 
     @cached_property
     @override

veadk/runner.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import functools
+import os
 from types import MethodType
 from typing import Union
 
@@ -249,15 +249,21 @@ class Runner(ADKRunner):
         )
 
         if self.short_term_memory:
-            await self.short_term_memory.create_session(
-                app_name=self.app_name, user_id=self.user_id, session_id=session_id
+            session = await self.short_term_memory.create_session(
+                app_name=self.app_name, user_id=user_id, session_id=session_id
+            )
+            assert session, (
+                f"Failed to create session with app_name={self.app_name}, user_id={user_id}, session_id={session_id}, "
+            )
+            logger.debug(
+                f"Auto create session: {session.id}, user_id: {session.user_id}, app_name: {self.app_name}"
             )
 
         final_output = ""
         for converted_message in converted_messages:
             try:
                 async for event in self.run_async(
-                    user_id=self.user_id,
+                    user_id=user_id,
                     session_id=session_id,
                     new_message=converted_message,
                     run_config=run_config,
@@ -359,19 +365,28 @@ class Runner(ADKRunner):
         )
         return eval_set_path
 
-    async def save_session_to_long_term_memory(self, session_id: str) -> None:
+    async def save_session_to_long_term_memory(
+        self, session_id: str, user_id: str = "", app_name: str = ""
+    ) -> None:
         if not self.long_term_memory:
             logger.warning("Long-term memory is not enabled. Failed to save session.")
             return
 
+        if not user_id:
+            user_id = self.user_id
+
+        if not app_name:
+            app_name = self.app_name
+
         session = await self.session_service.get_session(
-            app_name=self.app_name,
-            user_id=self.user_id,
+            app_name=app_name,
+            user_id=user_id,
             session_id=session_id,
         )
+
         if not session:
             logger.error(
-                f"Session {session_id} not found in session service, cannot save to long-term memory."
+                f"Session {session_id} (app_name={app_name}, user_id={user_id}) not found in session service, cannot save to long-term memory."
             )
             return
 

veadk/tools/builtin_tools/generate_image.py

@@ -12,28 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import base64
+import json
+import mimetypes
+import traceback
 from typing import Dict
 
 from google.adk.tools import ToolContext
-from veadk.config import getenv
-from veadk.consts import DEFAULT_IMAGE_GENERATE_MODEL_NAME, DEFAULT_MODEL_AGENT_API_BASE
-
-import base64
-from volcenginesdkarkruntime import Ark
+from google.genai.types import Blob, Part
 from opentelemetry import trace
-import traceback
-from veadk.version import VERSION
 from opentelemetry.trace import Span
-from veadk.utils.logger import get_logger
+from volcenginesdkarkruntime import Ark
 from volcenginesdkarkruntime.types.images.images import SequentialImageGenerationOptions
-import json
 
+from veadk.config import getenv
+from veadk.consts import DEFAULT_IMAGE_GENERATE_MODEL_NAME, DEFAULT_MODEL_AGENT_API_BASE
+from veadk.utils.logger import get_logger
+from veadk.utils.misc import formatted_timestamp, read_png_to_bytes
+from veadk.version import VERSION
 
 logger = get_logger(__name__)
 
 client = Ark(
     api_key=getenv("MODEL_AGENT_API_KEY"),
-    base_url=DEFAULT_MODEL_AGENT_API_BASE,
+    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
 )
 
 
@@ -121,7 +123,7 @@ async def image_generate(
     - size 推荐使用 2048x2048 或表格里的标准比例，确保生成质量。
     """
 
-    success_list = []
+    success_list: list[dict] = []
     error_list = []
 
     for idx, item in enumerate(tasks):
@@ -184,7 +186,9 @@ async def image_generate(
                     and max_images
                 ):
                     response = client.images.generate(
-                        model=DEFAULT_IMAGE_GENERATE_MODEL_NAME,
+                        model=getenv(
+                            "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                        ),
                         **inputs,
                         sequential_image_generation_options=SequentialImageGenerationOptions(
                             max_images=max_images
@@ -192,7 +196,10 @@ async def image_generate(
                     )
                 else:
                     response = client.images.generate(
-                        model=DEFAULT_IMAGE_GENERATE_MODEL_NAME, **inputs
+                        model=getenv(
+                            "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                        ),
+                        **inputs,
                     )
                 if not response.error:
                     for i, image_data in enumerate(response.data):
@@ -261,8 +268,12 @@ async def image_generate(
                 output_part=output_part,
                 output_tokens=output_tokens,
                 total_tokens=total_tokens,
-                request_model=DEFAULT_IMAGE_GENERATE_MODEL_NAME,
-                response_model=DEFAULT_IMAGE_GENERATE_MODEL_NAME,
+                request_model=getenv(
+                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                ),
+                response_model=getenv(
+                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                ),
             )
     if len(success_list) == 0:
         return {
@@ -271,6 +282,28 @@ async def image_generate(
             "error_list": error_list,
         }
     else:
+        app_name = tool_context._invocation_context.app_name
+        user_id = tool_context._invocation_context.user_id
+        session_id = tool_context._invocation_context.session.id
+
+        artifact_service = tool_context._invocation_context.artifact_service
+        if artifact_service:
+            for image in success_list:
+                for _, image_tos_url in image.items():
+                    filename = f"artifact_{formatted_timestamp()}"
+                    await artifact_service.save_artifact(
+                        app_name=app_name,
+                        user_id=user_id,
+                        session_id=session_id,
+                        filename=filename,
+                        artifact=Part(
+                            inline_data=Blob(
+                                display_name=filename,
+                                data=read_png_to_bytes(image_tos_url),
+                                mime_type=mimetypes.guess_type(image_tos_url)[0],
+                            )
+                        ),
+                    )
         return {
             "status": "success",
             "success_list": success_list,
@@ -332,10 +365,11 @@ def add_span_attributes(
 
 def _upload_image_to_tos(image_bytes: bytes, object_key: str) -> None:
     try:
-        from veadk.integrations.ve_tos.ve_tos import VeTOS
         import os
         from datetime import datetime
 
+        from veadk.integrations.ve_tos.ve_tos import VeTOS
+
         timestamp: str = datetime.now().strftime("%Y%m%d%H%M%S%f")[:-3]
         object_key = f"{timestamp}-{object_key}"
         bucket_name = os.getenv("DATABASE_TOS_BUCKET")

veadk/tools/builtin_tools/image_edit.py

@@ -29,7 +29,7 @@ logger = get_logger(__name__)
 
 client = Ark(
     api_key=getenv("MODEL_AGENT_API_KEY"),
-    base_url=DEFAULT_MODEL_AGENT_API_BASE,
+    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
 )
 
 
@@ -123,7 +123,8 @@ async def image_edit(
                     "parts.1.image_url.url": origin_image,
                 }
                 response = client.images.generate(
-                    model=DEFAULT_IMAGE_EDIT_MODEL_NAME, **inputs
+                    model=getenv("MODEL_EDIT_NAME", DEFAULT_IMAGE_EDIT_MODEL_NAME),
+                    **inputs,
                 )
                 output_part = None
                 if response.data and len(response.data) > 0:
@@ -175,8 +176,12 @@ async def image_edit(
                     output_part=output_part,
                     output_tokens=response.usage.output_tokens,
                     total_tokens=response.usage.total_tokens,
-                    request_model=DEFAULT_IMAGE_EDIT_MODEL_NAME,
-                    response_model=DEFAULT_IMAGE_EDIT_MODEL_NAME,
+                    request_model=getenv(
+                        "MODEL_EDIT_NAME", DEFAULT_IMAGE_EDIT_MODEL_NAME
+                    ),
+                    response_model=getenv(
+                        "MODEL_EDIT_NAME", DEFAULT_IMAGE_EDIT_MODEL_NAME
+                    ),
                 )
 
         except Exception as e:

veadk/tools/builtin_tools/image_generate.py

@@ -30,7 +30,7 @@ logger = get_logger(__name__)
 
 client = Ark(
     api_key=getenv("MODEL_AGENT_API_KEY"),
-    base_url=DEFAULT_MODEL_AGENT_API_BASE,
+    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
 )
 
 
@@ -120,7 +120,8 @@ async def image_generate(
                     "content": json.dumps(inputs, ensure_ascii=False),
                 }
                 response = client.images.generate(
-                    model=DEFAULT_TEXT_TO_IMAGE_MODEL_NAME, **inputs
+                    model=getenv("MODEL_IMAGE_NAME", DEFAULT_TEXT_TO_IMAGE_MODEL_NAME),
+                    **inputs,
                 )
                 output_part = None
                 if response.data and len(response.data) > 0:
@@ -172,8 +173,12 @@ async def image_generate(
                     output_part=output_part,
                     output_tokens=response.usage.output_tokens,
                     total_tokens=response.usage.total_tokens,
-                    request_model=DEFAULT_TEXT_TO_IMAGE_MODEL_NAME,
-                    response_model=DEFAULT_TEXT_TO_IMAGE_MODEL_NAME,
+                    request_model=getenv(
+                        "MODEL_IMAGE_NAME", DEFAULT_TEXT_TO_IMAGE_MODEL_NAME
+                    ),
+                    response_model=getenv(
+                        "MODEL_IMAGE_NAME", DEFAULT_TEXT_TO_IMAGE_MODEL_NAME
+                    ),
                 )
 
         except Exception as e:

veadk/tools/builtin_tools/video_generate.py

@@ -34,7 +34,7 @@ logger = get_logger(__name__)
 
 client = Ark(
     api_key=getenv("MODEL_AGENT_API_KEY"),
-    base_url=DEFAULT_MODEL_AGENT_API_BASE,
+    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
 )
 
 
@@ -43,7 +43,7 @@ async def generate(prompt, first_frame_image=None, last_frame_image=None):
         if first_frame_image is None:
             logger.debug("text generation")
             response = client.content_generation.tasks.create(
-                model=DEFAULT_VIDEO_MODEL_NAME,
+                model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=[
                     {"type": "text", "text": prompt},
                 ],
@@ -51,7 +51,7 @@ async def generate(prompt, first_frame_image=None, last_frame_image=None):
         elif last_frame_image is None:
             logger.debug("first frame generation")
             response = client.content_generation.tasks.create(
-                model=DEFAULT_VIDEO_MODEL_NAME,
+                model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=cast(
                     list[CreateTaskContentParam],  # avoid IDE warning
                     [
@@ -66,7 +66,7 @@ async def generate(prompt, first_frame_image=None, last_frame_image=None):
         else:
             logger.debug("last frame generation")
             response = client.content_generation.tasks.create(
-                model=DEFAULT_VIDEO_MODEL_NAME,
+                model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=[
                     {"type": "text", "text": prompt},
                     {
@@ -263,8 +263,8 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
                 output_part=output_part,
                 output_tokens=total_tokens,
                 total_tokens=total_tokens,
-                request_model=DEFAULT_VIDEO_MODEL_NAME,
-                response_model=DEFAULT_VIDEO_MODEL_NAME,
+                request_model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
+                response_model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
             )
 
     if len(success_list) == 0:

veadk/tools/builtin_tools/web_search.py

@@ -23,6 +23,7 @@ import json
 from urllib.parse import quote
 
 import requests
+from google.adk.tools import ToolContext
 
 from veadk.config import getenv
 from veadk.utils.logger import get_logger
@@ -151,7 +152,7 @@ def request(method, date, query, header, ak, sk, action, body):
     return r.json()
 
 
-def web_search(query: str) -> list[str]:
+def web_search(query: str, tool_context: ToolContext) -> list[str]:
     """Search a query in websites.
 
     Args:
@@ -166,8 +167,14 @@ def web_search(query: str) -> list[str]:
         "Count": 5,
         "NeedSummary": True,
     }
-    ak = getenv("VOLCENGINE_ACCESS_KEY")
-    sk = getenv("VOLCENGINE_SECRET_KEY")
+
+    ak = tool_context.state.get("VOLCENGINE_ACCESS_KEY")
+    if not ak:
+        ak = getenv("VOLCENGINE_ACCESS_KEY")
+
+    sk = tool_context.state.get("VOLCENGINE_SECRET_KEY")
+    if not sk:
+        sk = getenv("VOLCENGINE_SECRET_KEY")
 
     now = datetime.datetime.utcnow()
     response_body = request(

veadk/tools/load_knowledgebase_tool.py

@@ -25,6 +25,9 @@ from typing_extensions import override
 
 from veadk.knowledgebase import KnowledgeBase
 from veadk.knowledgebase.entry import KnowledgebaseEntry
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 if TYPE_CHECKING:
     from google.adk.models.llm_request import LlmRequest
@@ -96,6 +99,15 @@ class LoadKnowledgebaseTool(FunctionTool):
 
     def __init__(self):
         super().__init__(load_knowledgebase)
+        global knowledgebase
+        if knowledgebase is None:
+            logger.info(
+                "Get global knowledgebase instance failed, failed to set knowledgebase tool backend."
+            )
+        else:
+            if not self.custom_metadata:
+                self.custom_metadata = {}
+            self.custom_metadata["backend"] = knowledgebase.backend
 
     @override
     def _get_declaration(self) -> types.FunctionDeclaration | None:

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

@@ -325,6 +325,10 @@ def llm_gen_ai_operation_name(params: LLMAttributesParams) -> ExtractorResponse:
     return ExtractorResponse(content="chat")
 
 
+def llm_gen_ai_span_kind(params: LLMAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="llm")
+
+
 # def llm_gen_ai_system_message(params: LLMAttributesParams) -> ExtractorResponse:
 #     event_attributes = {
 #         "content": str(params.llm_request.config.system_instruction),
@@ -559,6 +563,7 @@ LLM_ATTRIBUTES = {
     "gen_ai.is_streaming": llm_gen_ai_is_streaming,
     # -> 1.4. span kind
     "gen_ai.operation.name": llm_gen_ai_operation_name,
+    "gen_ai.span.kind": llm_gen_ai_span_kind,  # apmplus required
     # -> 1.5. inputs
     "gen_ai.prompt": llm_gen_ai_prompt,
     # -> 1.6. outputs

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

@@ -23,6 +23,10 @@ def tool_gen_ai_operation_name(params: ToolAttributesParams) -> ExtractorRespons
     return ExtractorResponse(content="execute_tool")
 
 
+def tool_gen_ai_span_kind(params: ToolAttributesParams) -> ExtractorResponse:
+    return ExtractorResponse(content="tool")
+
+
 def tool_gen_ai_tool_message(params: ToolAttributesParams) -> ExtractorResponse:
     tool_input = {
         "role": "tool",
@@ -73,4 +77,7 @@ TOOL_ATTRIBUTES = {
     "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
+    "gen_ai.span.kind": tool_gen_ai_span_kind,  # apmplus required
+    "gen_ai.input": tool_gen_ai_tool_input,  # apmplus required
+    "gen_ai.output": tool_gen_ai_tool_output,  # apmplus required
 }

veadk/tracing/telemetry/exporters/apmplus_exporter.py

@@ -17,8 +17,10 @@ from dataclasses import dataclass
 from typing import Any
 
 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 import metrics, trace
 from opentelemetry import metrics as metrics_api
 from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
@@ -124,6 +126,12 @@ class Meters:
         "gen_ai.chat_completions.streaming_time_per_output_token"
     )
 
+    # apmplus metrics
+    # span duration
+    APMPLUS_SPAN_LATENCY = "apmplus_span_latency"
+    # tool token usage
+    APMPLUS_TOOL_TOKEN_USAGE = "apmplus_tool_token_usage"
+
 
 class MeterUploader:
     def __init__(
@@ -195,7 +203,21 @@ class MeterUploader:
             explicit_bucket_boundaries_advisory=_GEN_AI_SERVER_TIME_PER_OUTPUT_TOKEN_BUCKETS,
         )
 
-    def record(
+        # apmplus metrics for veadk dashboard
+        self.apmplus_span_latency = self.meter.create_histogram(
+            name=Meters.APMPLUS_SPAN_LATENCY,
+            description="Latency of span",
+            unit="s",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_OPERATION_DURATION_BUCKETS,
+        )
+        self.apmplus_tool_token_usage = self.meter.create_histogram(
+            name=Meters.APMPLUS_TOOL_TOKEN_USAGE,
+            description="Token consumption of APMPlus tool token",
+            unit="count",
+            explicit_bucket_boundaries_advisory=_GEN_AI_CLIENT_TOKEN_USAGE_BUCKETS,
+        )
+
+    def record_call_llm(
         self,
         invocation_context: InvocationContext,
         event_id: str,
@@ -205,7 +227,8 @@ class MeterUploader:
         attributes = {
             "gen_ai_system": "volcengine",
             "gen_ai_response_model": llm_request.model,
-            "gen_ai_operation_name": "chat_completions",
+            "gen_ai_operation_name": "chat",
+            "gen_ai_operation_type": "llm",
             "stream": "false",
             "server_address": "api.volcengine.com",
         }  # required by Volcengine APMPlus
@@ -267,6 +290,63 @@ class MeterUploader:
             #         time_per_output_token, attributes=attributes
             #     )
 
+            # add span name attribute
+            span = trace.get_current_span()
+            if not span:
+                return
+
+            # record span latency
+            if hasattr(span, "start_time") and self.apmplus_span_latency:
+                # span 耗时
+                duration = (time.time_ns() - span.start_time) / 1e9  # type: ignore
+                self.apmplus_span_latency.record(duration, attributes=attributes)
+
+    def record_tool_call(
+        self,
+        tool: BaseTool,
+        args: dict[str, Any],
+        function_response_event: Event,
+    ):
+        logger.debug(f"Record tool call work in progress. Tool: {tool.name}")
+        span = trace.get_current_span()
+        if not span:
+            return
+        operation_type = "tool"
+        operation_name = tool.name
+        operation_backend = ""
+        if tool.custom_metadata:
+            operation_backend = tool.custom_metadata.get("backend", "")
+
+        attributes = {
+            "gen_ai_operation_name": operation_name,
+            "gen_ai_operation_type": operation_type,
+            "gen_ai_operation_backend": operation_backend,
+        }
+
+        if hasattr(span, "start_time") and self.apmplus_span_latency:
+            # span 耗时
+            duration = (time.time_ns() - span.start_time) / 1e9  # type: ignore
+            self.apmplus_span_latency.record(duration, attributes=attributes)
+
+        if self.apmplus_tool_token_usage and hasattr(span, "attributes"):
+            tool_input = span.attributes["gen_ai.tool.input"]
+            tool_token_usage_input = (
+                len(tool_input) / 4
+            )  # tool token 数量，使用文本长度/4
+            input_tool_token_attributes = {**attributes, "token_type": "input"}
+            self.apmplus_tool_token_usage.record(
+                tool_token_usage_input, attributes=input_tool_token_attributes
+            )
+
+            tool_output = span.attributes["gen_ai.tool.output"]
+            tool_token_usage_output = (
+                len(tool_output) / 4
+            )  # tool token 数量，使用文本长度/4
+            output_tool_token_attributes = {**attributes, "token_type": "output"}
+            self.apmplus_tool_token_usage.record(
+                tool_token_usage_output, attributes=output_tool_token_attributes
+            )
+
 
 class APMPlusExporterConfig(BaseModel):
     endpoint: str = Field(

veadk/tracing/telemetry/exporters/inmemory_exporter.py

@@ -79,14 +79,20 @@ class _InMemorySpanProcessor(export.SimpleSpanProcessor):
     def on_start(self, span, parent_context) -> None:
         if span.name.startswith("invocation"):
             span.set_attribute("gen_ai.operation.name", "chain")
+            span.set_attribute("gen_ai.span.kind", "workflow")
             span.set_attribute("gen_ai.usage.total_tokens", 0)
-
             ctx = set_value("invocation_span_instance", span, context=parent_context)
+            # suppress instrumentation for llm to avoid auto instrument from apmplus, such as openai
+            ctx = set_value(
+                "suppress_language_model_instrumentation", True, context=ctx
+            )
+
             token = attach(ctx)  # mount context on `invocation` root span in Google ADK
             setattr(span, "_invocation_token", token)  # for later detach
 
-        if span.name.startswith("agent_run"):
+        if span.name.startswith("agent_run") or span.name.startswith("invoke_agent"):
             span.set_attribute("gen_ai.operation.name", "agent")
+            span.set_attribute("gen_ai.span.kind", "agent")
 
             ctx = set_value("agent_run_span_instance", span, context=parent_context)
             token = attach(ctx)