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

veadk/cloud/cloud_agent_engine.py

@@ -13,14 +13,17 @@
 # limitations under the License.
 
 import os
+import socket
+import subprocess
+import time
 from pathlib import Path
 from typing import Any
 
 from pydantic import BaseModel
 
-from veadk.cli.services.vefaas import VeFaaS
 from veadk.cloud.cloud_app import CloudApp
 from veadk.config import getenv
+from veadk.integrations.ve_faas.ve_faas import VeFaaS
 from veadk.utils.logger import get_logger
 from veadk.utils.misc import formatted_timestamp
 
@@ -52,37 +55,68 @@ class CloudAgentEngine(BaseModel):
                 f"Invalid Volcengine FaaS function name `{name}`, please use lowercase letters and numbers, or replace it with a `-` char."
             )
 
-        # project structure check
-        assert os.path.exists(os.path.join(path, "agent.py")), (
-            f"Local agent project path `{path}` does not contain `agent.py` file. Please prepare it according to our document https://volcengine.github.io/veadk-python/deploy.html"
+        # # copy user's requirements.txt
+        # module = load_module_from_file(
+        #     module_name="agent_source", file_path=f"{path}/agent.py"
+        # )
+
+        # requirement_file_path = module.agent_run_config.requirement_file_path
+        # if Path(requirement_file_path).exists():
+        #     shutil.copy(requirement_file_path, os.path.join(path, "requirements.txt"))
+
+        #     logger.info(
+        #         f"Copy requirement file: from {requirement_file_path} to {path}/requirements.txt"
+        #     )
+        # else:
+        #     logger.warning(
+        #         f"Requirement file: {requirement_file_path} not found or you have no requirement file in your project. Use a default one."
+        #     )
+
+    def _try_launch_fastapi_server(self, path: str):
+        """Try to launch a fastapi server for tests according to user's configuration.
+
+        Args:
+            path (str): Local agent project path.
+        """
+        RUN_SH = f"{path}/run.sh"
+
+        HOST = "0.0.0.0"
+        PORT = 8000
+
+        # Prepare environment variables
+        os.environ["_FAAS_FUNC_TIMEOUT"] = "900"
+        env = os.environ.copy()
+
+        process = subprocess.Popen(
+            ["bash", RUN_SH],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            env=env,
+            bufsize=1,
         )
 
-        if not os.path.exists(os.path.join(path, "config.yaml")):
-            logger.warning(
-                f"Local agent project path `{path}` does not contain `config.yaml` file. Some important config items may not be set."
-            )
+        timeout = 30
+        start_time = time.time()
 
-        # prepare template files if not have
-        template_files = [
-            "app.py",
-            "studio_app.py",
-            "run.sh",
-            "requirements.txt",
-            "__init__.py",
-        ]
-        for template_file in template_files:
-            if os.path.exists(os.path.join(path, template_file)):
-                logger.warning(
-                    f"Local agent project path `{path}` contains a `{template_file}` file. Use your own `{template_file}` file may cause unexpected behavior."
-                )
-            else:
-                logger.info(
-                    f"No `{template_file}` detected in local agent project path `{path}`. Prepare it."
-                )
-                template_file_path = f"{Path(__file__).resolve().parent.resolve().parent.resolve()}/cli/services/vefaas/template/src/{template_file}"
-                import shutil
+        for line in process.stdout:  # type: ignore
+            print(line, end="")
 
-                shutil.copy(template_file_path, os.path.join(path, template_file))
+            if time.time() - start_time > timeout:
+                process.terminate()
+                raise RuntimeError(f"FastAPI server failed to start on {HOST}:{PORT}")
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                    s.settimeout(0.1)
+                    s.connect(("127.0.0.1", PORT))
+                    logger.info(f"FastAPI server is listening on {HOST}:{PORT}")
+                    logger.info("Local deplyment test successfully.")
+                    break
+            except (ConnectionRefusedError, socket.timeout):
+                continue
+
+        process.terminate()
+        process.wait()
 
     def deploy(
         self,
@@ -91,34 +125,28 @@ class CloudAgentEngine(BaseModel):
         gateway_name: str = "",
         gateway_service_name: str = "",
         gateway_upstream_name: str = "",
-        use_studio: bool = False,
         use_adk_web: bool = False,
+        local_test: bool = False,
     ) -> CloudApp:
         """Deploy local agent project to Volcengine FaaS platform.
 
         Args:
+            application_name (str): Expected VeFaaS application name.
             path (str): Local agent project path.
-            name (str): Volcengine FaaS function name.
+            gateway_name (str): Gateway name.
+            gateway_service_name (str): Gateway service name.
+            gateway_upstream_name (str): Gateway upstream name.
+            use_adk_web (bool): Whether to use ADK Web.
+            local_test (bool): Whether to run local test for FastAPI Server.
 
         Returns:
-            str: Volcengine FaaS function endpoint.
+            CloudApp: The deployed cloud application instance.
         """
-        assert not (use_studio and use_adk_web), (
-            "use_studio and use_adk_web can not be True at the same time."
-        )
-
         # prevent deepeval writing operations
         import veadk.config
 
         veadk.config.veadk_environments["DEEPEVAL_TELEMETRY_OPT_OUT"] = "YES"
 
-        if use_studio:
-            veadk.config.veadk_environments["USE_STUDIO"] = "True"
-        else:
-            import veadk.config
-
-            veadk.config.veadk_environments["USE_STUDIO"] = "False"
-
         if use_adk_web:
             import veadk.config
 
@@ -132,6 +160,9 @@ class CloudAgentEngine(BaseModel):
         path = str(Path(path).resolve())
         self._prepare(path, application_name)
 
+        if local_test:
+            self._try_launch_fastapi_server(path)
+
         if not gateway_name:
             gateway_name = f"{application_name}-gw-{formatted_timestamp()}"
         if not gateway_service_name:
@@ -166,6 +197,10 @@ class CloudAgentEngine(BaseModel):
             return
         else:
             app_id = self._vefaas_service.find_app_id_by_name(app_name)
+            if not app_id:
+                raise ValueError(
+                    f"Cloud app {app_name} not found, cannot delete it. Please check the app name."
+                )
             self._vefaas_service.delete(app_id)
 
     def update_function_code(

veadk/cloud/cloud_app.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 from typing import Any
 from uuid import uuid4
 
-import json
 import httpx
 from a2a.client import A2ACardResolver, A2AClient
 from a2a.types import AgentCard, Message, MessageSendParams, SendMessageRequest
@@ -79,14 +79,21 @@ class CloudApp:
         volcengine_ak: str = getenv("VOLCENGINE_ACCESS_KEY"),
         volcengine_sk: str = getenv("VOLCENGINE_SECRET_KEY"),
     ) -> str:
-        from veadk.cli.services.vefaas.vefaas import VeFaaS
+        from veadk.integrations.ve_faas.ve_faas import VeFaaS
 
         vefaas_client = VeFaaS(access_key=volcengine_ak, secret_key=volcengine_sk)
+
         app = vefaas_client.get_application_details(
             app_id=self.vefaas_application_id,
             app_name=self.vefaas_application_name,
         )
+
+        if not app:
+            raise ValueError(
+                f"VeFaaS CloudAPP with application_id `{self.vefaas_application_id}` or application_name `{self.vefaas_application_name}` not found."
+            )
         cloud_resource = json.loads(app["CloudResource"])
+
         try:
             vefaas_endpoint = cloud_resource["framework"]["url"]["system_url"]
         except Exception as e:
@@ -98,8 +105,15 @@ class CloudApp:
             raise ValueError(
                 "VeFaaS CloudAPP must be set application_name to get application_id."
             )
-        # TODO(zakahan): get application id from vefaas application name
-        vefaas_application_id = ""
+        from veadk.integrations.ve_faas.ve_faas import VeFaaS
+
+        vefaas_client = VeFaaS(
+            access_key=getenv("VOLCENGINE_ACCESS_KEY"),
+            secret_key=getenv("VOLCENGINE_SECRET_KEY"),
+        )
+        vefaas_application_id = vefaas_client.find_app_id_by_name(
+            self.vefaas_application_name
+        )
         return vefaas_application_id
 
     async def _get_a2a_client(self) -> A2AClient:
@@ -149,7 +163,7 @@ class CloudApp:
             print("Delete cancelled.")
             return
         else:
-            from veadk.cli.services.vefaas.vefaas import VeFaaS
+            from veadk.integrations.ve_faas.ve_faas import VeFaaS
 
             vefaas_client = VeFaaS(access_key=volcengine_ak, secret_key=volcengine_sk)
             vefaas_client.delete(self.vefaas_application_id)
@@ -180,12 +194,29 @@ class CloudApp:
                     id=uuid4().hex,
                     params=MessageSendParams(**send_message_payload),
                 )
+
                 res = await a2a_client.send_message(
                     message_send_request,
                     http_kwargs={"timeout": httpx.Timeout(timeout)},
                 )
-                return res.root.result
+
+                logger.debug(
+                    f"Message sent to cloud app {self.vefaas_application_name} with response: {res}"
+                )
+
+                # we ignore type checking here, because the response
+                # from CloudApp will not be `Task` type
+                return res.root.result  # type: ignore
             except Exception as e:
                 # TODO(floritange): show error log on VeFaaS function
                 print(e)
                 return None
+
+
+def get_message_id(message: Message):
+    """Get the messageId of the a2a message"""
+    if getattr(message, "messageId", None):
+        # Compatible with the messageId of the old a2a-python version (<0.3.0) in cloud app
+        return message.messageId  # type: ignore
+    else:
+        return message.message_id

veadk/database/database_adapter.py

@@ -15,8 +15,8 @@
 import re
 import time
 from typing import BinaryIO, TextIO
-from veadk.database.base_database import BaseDatabase
 
+from veadk.database.base_database import BaseDatabase
 from veadk.utils.logger import get_logger
 
 logger = get_logger(__name__)
@@ -41,7 +41,7 @@ class KVDatabaseAdapter:
             )
             raise e
 
-    def query(self, query: str, index: str, top_k: int = 0) -> list[str]:
+    def query(self, query: str, index: str, top_k: int = 0) -> list:
         logger.debug(f"Querying Redis database: index={index} query={query}")
 
         # ignore top_k, as KV search only return one result

veadk/database/kv/redis_database.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from typing import Any
 
 import redis
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field
 from typing_extensions import override
 
 from veadk.config import getenv
@@ -30,19 +30,19 @@ logger = get_logger(__name__)
 
 class RedisDatabaseConfig(BaseModel):
     host: str = Field(
-        default=getenv("DATABASE_REDIS_HOST"),
+        default_factory=lambda: getenv("DATABASE_REDIS_HOST"),
         description="Redis host",
     )
     port: int = Field(
-        default=getenv("DATABASE_REDIS_PORT"),
+        default_factory=lambda: int(getenv("DATABASE_REDIS_PORT")),
         description="Redis port",
     )
     db: int = Field(
-        default=getenv("DATABASE_REDIS_DB"),
+        default_factory=lambda: int(getenv("DATABASE_REDIS_DB")),
         description="Redis db",
     )
     password: str = Field(
-        default=getenv("DATABASE_REDIS_PASSWORD"),
+        default_factory=lambda: getenv("DATABASE_REDIS_PASSWORD"),
         description="Redis password",
     )
     decode_responses: bool = Field(
@@ -53,7 +53,6 @@ class RedisDatabaseConfig(BaseModel):
 
 class RedisDatabase(BaseModel, BaseDatabase):
     config: RedisDatabaseConfig = Field(default_factory=RedisDatabaseConfig)
-    _client: redis.Redis = PrivateAttr(default=None)
 
     def model_post_init(self, context: Any, /) -> None:
         try:
@@ -64,6 +63,7 @@ class RedisDatabase(BaseModel, BaseDatabase):
                 password=self.config.password,
                 decode_responses=self.config.decode_responses,
             )
+
             self._client.ping()
             logger.info("Connected to Redis successfully.")
         except Exception as e:
@@ -79,10 +79,10 @@ class RedisDatabase(BaseModel, BaseDatabase):
             raise e
 
     @override
-    def query(self, key: str, query: str = "", **kwargs) -> list[str]:
+    def query(self, key: str, query: str = "", **kwargs) -> list:
         try:
             result = self._client.lrange(key, 0, -1)
-            return result
+            return result  # type: ignore
         except Exception as e:
             logger.error(f"Failed to search from Redis list key '{key}': {e}")
             raise e
@@ -99,8 +99,11 @@ class RedisDatabase(BaseModel, BaseDatabase):
 
         try:
             # For simple key deletion
+            # We use sync Redis client to delete the key
+            # so the result will be `int`
             result = self._client.delete(key)
-            if result > 0:
+
+            if result > 0:  # type: ignore
                 logger.info(f"Deleted key `{key}` from Redis.")
             else:
                 logger.info(f"Key `{key}` not found in Redis. Skipping deletion.")

veadk/database/relational/mysql_database.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from typing import Any
 
 import pymysql
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field
 from typing_extensions import override
 
 from veadk.config import getenv
@@ -30,23 +30,23 @@ logger = get_logger(__name__)
 
 class MysqlDatabaseConfig(BaseModel):
     host: str = Field(
-        default=getenv("DATABASE_MYSQL_HOST"),
+        default_factory=lambda: getenv("DATABASE_MYSQL_HOST"),
         description="Mysql host",
     )
     user: str = Field(
-        default=getenv("DATABASE_MYSQL_USER"),
+        default_factory=lambda: getenv("DATABASE_MYSQL_USER"),
         description="Mysql user",
     )
     password: str = Field(
-        default=getenv("DATABASE_MYSQL_PASSWORD"),
+        default_factory=lambda: getenv("DATABASE_MYSQL_PASSWORD"),
         description="Mysql password",
     )
     database: str = Field(
-        default=getenv("DATABASE_MYSQL_DATABASE"),
+        default_factory=lambda: getenv("DATABASE_MYSQL_DATABASE"),
         description="Mysql database",
     )
     charset: str = Field(
-        default=getenv("DATABASE_MYSQL_CHARSET", "utf8mb4"),
+        default_factory=lambda: getenv("DATABASE_MYSQL_CHARSET", "utf8mb4"),
         description="Mysql charset",
     )
 
@@ -54,8 +54,6 @@ class MysqlDatabaseConfig(BaseModel):
 class MysqlDatabase(BaseModel, BaseDatabase):
     config: MysqlDatabaseConfig = Field(default_factory=MysqlDatabaseConfig)
 
-    _connection: pymysql.Connection = PrivateAttr(default=None)
-
     def model_post_init(self, context: Any, /) -> None:
         self._connection = pymysql.connect(
             host=self.config.host,
@@ -65,6 +63,9 @@ class MysqlDatabase(BaseModel, BaseDatabase):
             charset=self.config.charset,
             cursorclass=pymysql.cursors.DictCursor,
         )
+        self._connection.ping()
+        logger.info("Connected to MySQL successfully.")
+
         self._type = "mysql"
 
     def table_exists(self, table: str) -> bool:
@@ -83,7 +84,7 @@ class MysqlDatabase(BaseModel, BaseDatabase):
             self._connection.commit()
 
     @override
-    def query(self, sql: str, params=None, **kwargs) -> list[str]:
+    def query(self, sql: str, params=None, **kwargs) -> tuple[dict[str, Any], ...]:
         with self._connection.cursor() as cursor:
             cursor.execute(sql, params)
             return cursor.fetchall()

veadk/database/vector/opensearch_vector_database.py

@@ -32,23 +32,29 @@ logger = get_logger(__name__)
 
 class OpenSearchVectorDatabaseConfig(BaseModel):
     host: str = Field(
-        default=getenv("DATABASE_OPENSEARCH_HOST"),
+        default_factory=lambda: getenv("DATABASE_OPENSEARCH_HOST"),
         description="OpenSearch host",
     )
+
     port: str | int = Field(
-        default=getenv("DATABASE_OPENSEARCH_PORT"),
+        default_factory=lambda: getenv("DATABASE_OPENSEARCH_PORT"),
         description="OpenSearch port",
     )
+
     username: Optional[str] = Field(
-        default=getenv("DATABASE_OPENSEARCH_USERNAME"),
+        default_factory=lambda: getenv("DATABASE_OPENSEARCH_USERNAME"),
         description="OpenSearch username",
     )
+
     password: Optional[str] = Field(
-        default=getenv("DATABASE_OPENSEARCH_PASSWORD"),
+        default_factory=lambda: getenv("DATABASE_OPENSEARCH_PASSWORD"),
         description="OpenSearch password",
     )
+
     secure: bool = Field(default=True, description="Whether enable SSL")
+
     verify_certs: bool = Field(default=False, description="Whether verify SSL certs")
+
     auth_method: Literal["basic", "aws_managed_iam"] = Field(
         default="basic", description="OpenSearch auth method"
     )
@@ -231,15 +237,16 @@ class OpenSearchVectorDatabase(BaseModel, BaseDatabase):
             for hit in response["hits"]["hits"]
         ]
 
-    def delete_by_query(self, collection_name: str, query: str):
+    def delete_by_query(self, collection_name: str, query: str) -> Any:
         """Delete docs by query in one index of OpenSearch"""
         if not self.collection_exists(collection_name):
             raise ValueError(f"Collection {collection_name} does not exist.")
 
-        query = {"query": {"match": {"page_content": query}}}
+        query_payload = {"query": {"match": {"page_content": query}}}
         response = self._opensearch_client.delete_by_query(
-            index=collection_name, body=query
+            index=collection_name, body=query_payload
         )
+
         self._opensearch_client.indices.refresh(index=collection_name)
         return response
 

veadk/database/viking/viking_database.py

@@ -16,7 +16,7 @@ import io
 import json
 import os
 import uuid
-from typing import Any, BinaryIO, Literal, Optional, TextIO
+from typing import Any, BinaryIO, Literal, TextIO
 
 import requests
 import tos
@@ -44,42 +44,44 @@ doc_del_path = "/api/collection/drop"
 
 
 class VolcengineTOSConfig(BaseModel):
-    endpoint: Optional[str] = Field(
-        default=getenv("DATABASE_TOS_ENDPOINT", "tos-cn-beijing.volces.com"),
+    endpoint: str = Field(
+        default_factory=lambda: getenv(
+            "DATABASE_TOS_ENDPOINT", "tos-cn-beijing.volces.com"
+        ),
         description="VikingDB TOS endpoint",
     )
-    region: Optional[str] = Field(
-        default=getenv("DATABASE_TOS_REGION", "cn-beijing"),
+    region: str = Field(
+        default_factory=lambda: getenv("DATABASE_TOS_REGION", "cn-beijing"),
         description="VikingDB TOS region",
     )
-    bucket: Optional[str] = Field(
-        default=getenv("DATABASE_TOS_BUCKET"),
+    bucket: str = Field(
+        default_factory=lambda: getenv("DATABASE_TOS_BUCKET"),
         description="VikingDB TOS bucket",
     )
-    base_key: Optional[str] = Field(
+    base_key: str = Field(
         default="veadk",
         description="VikingDB TOS base key",
     )
 
 
 class VikingDatabaseConfig(BaseModel):
-    volcengine_ak: Optional[str] = Field(
-        default=getenv("VOLCENGINE_ACCESS_KEY"),
+    volcengine_ak: str = Field(
+        default_factory=lambda: getenv("VOLCENGINE_ACCESS_KEY"),
         description="VikingDB access key",
     )
-    volcengine_sk: Optional[str] = Field(
-        default=getenv("VOLCENGINE_SECRET_KEY"),
+    volcengine_sk: str = Field(
+        default_factory=lambda: getenv("VOLCENGINE_SECRET_KEY"),
         description="VikingDB secret key",
     )
-    project: Optional[str] = Field(
-        default=getenv("DATABASE_VIKING_PROJECT"),
+    project: str = Field(
+        default_factory=lambda: getenv("DATABASE_VIKING_PROJECT"),
         description="VikingDB project name",
     )
-    region: Optional[str] = Field(
-        default=getenv("DATABASE_VIKING_REGION"),
+    region: str = Field(
+        default_factory=lambda: getenv("DATABASE_VIKING_REGION"),
         description="VikingDB region",
     )
-    tos: Optional[VolcengineTOSConfig] = Field(
+    tos: VolcengineTOSConfig = Field(
         default_factory=VolcengineTOSConfig,
         description="VikingDB TOS configuration",
     )
@@ -136,13 +138,17 @@ class VikingDatabase(BaseModel, BaseDatabase):
         file_ext = kwargs.get(
             "file_ext", ".pdf"
         )  # when bytes data, file_ext is required
+
         ak = self.config.volcengine_ak
         sk = self.config.volcengine_sk
+
         tos_bucket = self.config.tos.bucket
         tos_endpoint = self.config.tos.endpoint
         tos_region = self.config.tos.region
         tos_key = self.config.tos.base_key
+
         client = tos.TosClientV2(ak, sk, tos_endpoint, tos_region, max_connections=1024)
+
         if isinstance(data, str) and os.path.isfile(data):  # Process file path
             file_ext = os.path.splitext(data)[1]
             new_key = f"{tos_key}/{str(uuid.uuid4())}{file_ext}"

veadk/database/viking/viking_memory_db.py

@@ -18,7 +18,7 @@ import string
 import threading
 import time
 from datetime import datetime
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel, Field
 from volcengine.ApiInfo import ApiInfo
@@ -35,20 +35,20 @@ logger = get_logger(__name__)
 
 
 class VikingMemConfig(BaseModel):
-    volcengine_ak: Optional[str] = Field(
-        default=getenv("VOLCENGINE_ACCESS_KEY"),
+    volcengine_ak: str = Field(
+        default_factory=lambda: getenv("VOLCENGINE_ACCESS_KEY"),
         description="VikingDB access key",
     )
-    volcengine_sk: Optional[str] = Field(
-        default=getenv("VOLCENGINE_SECRET_KEY"),
+    volcengine_sk: str = Field(
+        default_factory=lambda: getenv("VOLCENGINE_SECRET_KEY"),
         description="VikingDB secret key",
     )
-    project: Optional[str] = Field(
-        default=getenv("DATABASE_VIKING_PROJECT"),
+    project: str = Field(
+        default_factory=lambda: getenv("DATABASE_VIKING_PROJECT"),
         description="VikingDB project name",
     )
-    region: Optional[str] = Field(
-        default=getenv("DATABASE_VIKING_REGION"),
+    region: str = Field(
+        default_factory=lambda: getenv("DATABASE_VIKING_REGION"),
         description="VikingDB region",
     )
 

veadk/evaluation/adk_evaluator/adk_evaluator.py

@@ -19,6 +19,7 @@ from os import path
 from typing import Any, Optional
 
 from google.adk import Runner
+from google.adk.agents.base_agent import BaseAgent
 from google.adk.artifacts import BaseArtifactService, InMemoryArtifactService
 from google.adk.evaluation.agent_evaluator import (
     NUM_RUNS,
@@ -68,7 +69,7 @@ class VeEvaluationGenerator(EvaluationGenerator):
         eval_set: EvalSet,
         agent: Agent,
         repeat_num: int = 3,
-        agent_name: str = None,
+        agent_name: str | None = None,
     ):
         results = []
 
@@ -90,7 +91,7 @@ class VeEvaluationGenerator(EvaluationGenerator):
     @staticmethod
     async def _ve_generate_inferences_from_root_agent(
         invocations: list[Invocation],
-        root_agent: Agent,
+        root_agent: BaseAgent,
         reset_func: Any,
         initial_session: Optional[SessionInput] = None,
         session_id: Optional[str] = None,
@@ -117,21 +118,15 @@ class VeEvaluationGenerator(EvaluationGenerator):
         if not artifact_service:
             artifact_service = InMemoryArtifactService()
 
-        if getattr(root_agent, "long_term_memory", None) is not None:
-            runner = Runner(
-                app_name=app_name,
-                agent=root_agent,
-                artifact_service=artifact_service,
-                session_service=session_service,
-                memory_service=root_agent.long_term_memory,  # add long_term_memory
-            )
-        else:
-            runner = Runner(
-                app_name=app_name,
-                agent=root_agent,
-                artifact_service=artifact_service,
-                session_service=session_service,
-            )
+        runner = Runner(
+            app_name=app_name,
+            agent=root_agent,
+            artifact_service=artifact_service,
+            session_service=session_service,
+            memory_service=root_agent.long_term_memory
+            if isinstance(root_agent, Agent)
+            else None,
+        )
 
         # Reset agent state for each query
         if callable(reset_func):