veadk-python 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

veadk/cli/cli.py

@@ -22,6 +22,7 @@ from veadk.cli.cli_kb import kb
 from veadk.cli.cli_pipeline import pipeline
 from veadk.cli.cli_prompt import prompt
 from veadk.cli.cli_web import web
+from veadk.cli.cli_uploadevalset import uploadevalset
 from veadk.version import VERSION
 
 
@@ -41,6 +42,7 @@ veadk.add_command(web)
 veadk.add_command(pipeline)
 veadk.add_command(eval)
 veadk.add_command(kb)
+veadk.add_command(uploadevalset)
 
 if __name__ == "__main__":
     veadk()

veadk/cli/cli_uploadevalset.py

@@ -0,0 +1,125 @@
+# 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 click
+import json
+import requests
+from veadk.utils.logger import get_logger
+from veadk.config import getenv
+from pathlib import Path
+
+logger = get_logger(__name__)
+
+
+@click.command()
+@click.option("--file", required=True, help="JSON file path containing dataset items")
+@click.option("--cozeloop-workspace-id", default=None, help="CozeLoop workspace ID")
+@click.option("--cozeloop-evalset-id", default=None, help="CozeLoop evaluation set ID")
+@click.option(
+    "--cozeloop-api-key",
+    default=None,
+    help="CozeLoop API key (or set COZELOOP_API_KEY env var)",
+)
+def uploadevalset(
+    file: str,
+    cozeloop_workspace_id: str,
+    cozeloop_evalset_id: str,
+    cozeloop_api_key: str,
+) -> None:
+    """Upload dataset items to CozeLoop evaluation set."""
+
+    if not cozeloop_workspace_id:
+        cozeloop_workspace_id = getenv(
+            "OBSERVABILITY_OPENTELEMETRY_COZELOOP_SERVICE_NAME"
+        )
+    if not cozeloop_evalset_id:
+        cozeloop_evalset_id = getenv("OBSERVABILITY_OPENTELEMETRY_COZELOOP_EVALSET_ID")
+    if not cozeloop_api_key:
+        cozeloop_api_key = getenv("OBSERVABILITY_OPENTELEMETRY_COZELOOP_API_KEY")
+
+    # Read JSON file
+    file_path = Path(file)
+    if not file_path.exists():
+        logger.error(f"File not found: {file}")
+        return
+
+    logger.info(f"Reading dataset from {file}")
+    with open(file_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    # Prepare items
+    items = []
+    for case in data.get("eval_cases", []):
+        conversation = case.get("conversation", [])
+        for turn in conversation:
+            user_text = (
+                turn.get("user_content", {}).get("parts", [{}])[0].get("text", "")
+            )
+            output_text = (
+                turn.get("final_response", {}).get("parts", [{}])[0].get("text", "")
+            )
+
+            items.append(
+                {
+                    "turns": [
+                        {
+                            "field_datas": [
+                                {
+                                    "name": "input",
+                                    "content": {
+                                        "content_type": "Text",
+                                        "text": user_text,
+                                    },
+                                },
+                                {
+                                    "name": "output",
+                                    "content": {
+                                        "content_type": "Text",
+                                        "text": output_text,
+                                    },
+                                },
+                            ]
+                        }
+                    ]
+                }
+            )
+
+    # Upload to CozeLoop
+    url = f"https://api.coze.cn/v1/loop/evaluation/evaluation_sets/{cozeloop_evalset_id}/items"
+    logger.info(
+        f"Uploading {len(items)} items to workspace_id={cozeloop_workspace_id} evalset_id={cozeloop_evalset_id}"
+    )
+
+    response = requests.post(
+        url=url,
+        headers={
+            "Authorization": f"Bearer {cozeloop_api_key}",
+            "Content-Type": "application/json",
+            "X-TT-ENV": "ppe_eval_openapi",
+            "x-use-ppe": "1",
+        },
+        json={
+            "workspace_id": cozeloop_workspace_id,
+            "is_allow_partial_add": True,
+            "is_skip_invalid_items": True,
+            "items": items,
+        },
+    )
+
+    if response.status_code == 200:
+        logger.info(
+            f"Successfully uploaded dataset to CozeLoop evalset {cozeloop_evalset_id}"
+        )
+    else:
+        logger.error(f"Failed to upload dataset: {response.text}")

veadk/cli/cli_web.py

@@ -56,10 +56,14 @@ def _get_ltm_from_env() -> LongTermMemory | None:
     logger = get_logger(__name__)
 
     long_term_memory_backend = os.getenv("LONG_TERM_MEMORY_BACKEND")
+    app_name = os.getenv("VEADK_WEB_APP_NAME", "")
+    user_id = os.getenv("VEADK_WEB_USER_ID", "")
 
     if long_term_memory_backend:
         logger.info(f"Long term memory: backend={long_term_memory_backend}")
-        return LongTermMemory(backend=long_term_memory_backend)  # type: ignore
+        return LongTermMemory(
+            backend=long_term_memory_backend, app_name=app_name, user_id=user_id
+        )  # type: ignore
     else:
         logger.warning("No long term memory backend settings detected.")
         return None
@@ -131,7 +135,13 @@ def patch_adkwebserver_disable_openapi():
 
 @click.command()
 @click.option("--host", default="127.0.0.1", help="Host to run the web server on")
-def web(host: str) -> None:
+@click.option(
+    "--app_name", default="", help="The `app_name` for initializing long term memory"
+)
+@click.option(
+    "--user_id", default="", help="The `user_id` for initializing long term memory"
+)
+def web(host: str, app_name: str, user_id: str) -> None:
     """Launch web with long term and short term memory."""
     import os
     from typing import Any
@@ -175,6 +185,9 @@ def web(host: str) -> None:
         self.session_service = short_term_memory.session_service
         self.memory_service = long_term_memory
 
+    os.environ["VEADK_WEB_APP_NAME"] = app_name
+    os.environ["VEADK_WEB_USER_ID"] = user_id
+
     import google.adk.cli.adk_web_server
 
     google.adk.cli.adk_web_server.AdkWebServer.__init__ = init_for_veadk

veadk/integrations/ve_tos/ve_tos.py

@@ -36,11 +36,14 @@ class VeTOS:
         self,
         ak: str = "",
         sk: str = "",
+        session_token: str = "",
         region: str = "cn-beijing",
         bucket_name: str = DEFAULT_TOS_BUCKET_NAME,
     ) -> None:
         self.ak = ak if ak else os.getenv("VOLCENGINE_ACCESS_KEY", "")
         self.sk = sk if sk else os.getenv("VOLCENGINE_SECRET_KEY", "")
+        self.session_token = session_token
+
         # Add empty value validation
         if not self.ak or not self.sk:
             raise ValueError(
@@ -71,6 +74,7 @@ class VeTOS:
             self._client = self._tos_module.TosClientV2(
                 ak=self.ak,
                 sk=self.sk,
+                security_token=self.session_token,
                 endpoint=f"tos-{self.region}.volces.com",
                 region=self.region,
             )
@@ -85,6 +89,7 @@ class VeTOS:
             self._client = self._tos_module.TosClientV2(
                 self.ak,
                 self.sk,
+                security_token=self.session_token,
                 endpoint=f"tos-{self.region}.volces.com",
                 region=self.region,
             )

veadk/knowledgebase/backends/utils.py

@@ -46,6 +46,7 @@ def build_vikingdb_knowledgebase_request(
     path: str,
     volcengine_access_key: str,
     volcengine_secret_key: str,
+    session_token: str = "",
     method: Literal["GET", "POST", "PUT", "DELETE"] = "POST",
     region: str = "cn-beijing",
     params=None,
@@ -85,7 +86,7 @@ def build_vikingdb_knowledgebase_request(
         r.set_body(json.dumps(data))
 
     credentials = Credentials(
-        volcengine_access_key, volcengine_secret_key, "air", region
+        volcengine_access_key, volcengine_secret_key, "air", region, session_token
     )
     SignerV4.sign(r, credentials)
     return r

veadk/knowledgebase/backends/vikingdb_knowledge_backend.py

@@ -14,6 +14,7 @@
 
 import asyncio
 import json
+import os
 import re
 from pathlib import Path
 from typing import Any, Literal
@@ -23,7 +24,7 @@ from pydantic import Field
 from typing_extensions import override
 
 import veadk.config  # noqa E401
-from veadk.config import getenv
+from veadk.auth.veauth.utils import get_credential_from_vefaas_iam
 from veadk.configs.database_configs import NormalTOSConfig, TOSConfig
 from veadk.knowledgebase.backends.base_backend import BaseKnowledgebaseBackend
 from veadk.knowledgebase.backends.utils import build_vikingdb_knowledgebase_request
@@ -58,14 +59,16 @@ def get_files_in_directory(directory: str):
 
 
 class VikingDBKnowledgeBackend(BaseKnowledgebaseBackend):
-    volcengine_access_key: str = Field(
-        default_factory=lambda: getenv("VOLCENGINE_ACCESS_KEY")
+    volcengine_access_key: str | None = Field(
+        default_factory=lambda: os.getenv("VOLCENGINE_ACCESS_KEY")
     )
 
-    volcengine_secret_key: str = Field(
-        default_factory=lambda: getenv("VOLCENGINE_SECRET_KEY")
+    volcengine_secret_key: str | None = Field(
+        default_factory=lambda: os.getenv("VOLCENGINE_SECRET_KEY")
     )
 
+    session_token: str = ""
+
     volcengine_project: str = "default"
     """VikingDB knowledgebase project in Volcengine console platform. Default by `default`"""
 
@@ -75,6 +78,15 @@ class VikingDBKnowledgeBackend(BaseKnowledgebaseBackend):
     tos_config: TOSConfig | NormalTOSConfig = Field(default_factory=TOSConfig)
     """TOS config, used to upload files to TOS"""
 
+    def model_post_init(self, __context: Any) -> None:
+        self.precheck_index_naming()
+
+        # check whether collection exist, if not, create it
+        if not self.collection_status()["existed"]:
+            logger.warning(
+                f"VikingDB knowledgebase collection {self.index} does not exist, please create it first..."
+            )
+
     def precheck_index_naming(self):
         if not (
             isinstance(self.index, str)
@@ -86,18 +98,21 @@ class VikingDBKnowledgeBackend(BaseKnowledgebaseBackend):
                 "it must start with an English letter, contain only letters, numbers, and underscores, and have a length of 1-128."
             )
 
-    def model_post_init(self, __context: Any) -> None:
-        self.precheck_index_naming()
-
-        # check whether collection exist, if not, create it
-        if not self.collection_status()["existed"]:
-            logger.warning(
-                f"VikingDB knowledgebase collection {self.index} does not exist, please create it first..."
-            )
-
-        self._tos_client = VeTOS(
-            ak=self.volcengine_access_key,
-            sk=self.volcengine_secret_key,
+    def _get_tos_client(self) -> VeTOS:
+        volcengine_access_key = self.volcengine_access_key
+        volcengine_secret_key = self.volcengine_secret_key
+        session_token = self.session_token
+
+        if not (volcengine_access_key and volcengine_secret_key):
+            cred = get_credential_from_vefaas_iam()
+            volcengine_access_key = cred.access_key_id
+            volcengine_secret_key = cred.secret_access_key
+            session_token = cred.session_token
+
+        return VeTOS(
+            ak=volcengine_access_key,
+            sk=volcengine_secret_key,
+            session_token=session_token,
             region=self.tos_config.region,
             bucket_name=self.tos_config.bucket,
         )
@@ -404,6 +419,8 @@ class VikingDBKnowledgeBackend(BaseKnowledgebaseBackend):
         metadata: dict | None = None,
     ) -> str:
         # Here, we set the metadata via the TOS object, ref: https://www.volcengine.com/docs/84313/1254624
+        self._tos_client = self._get_tos_client()
+
         self._tos_client.bucket_name = tos_bucket_name
         coro = self._tos_client.upload(
             object_key=object_key,
@@ -504,10 +521,21 @@ class VikingDBKnowledgeBackend(BaseKnowledgebaseBackend):
     ) -> dict:
         VIKINGDB_KNOWLEDGEBASE_BASE_URL = "api-knowledgebase.mlp.cn-beijing.volces.com"
 
+        volcengine_access_key = self.volcengine_access_key
+        volcengine_secret_key = self.volcengine_secret_key
+        session_token = self.session_token
+
+        if not (volcengine_access_key and volcengine_secret_key):
+            cred = get_credential_from_vefaas_iam()
+            volcengine_access_key = cred.access_key_id
+            volcengine_secret_key = cred.secret_access_key
+            session_token = cred.session_token
+
         request = build_vikingdb_knowledgebase_request(
             path=path,
-            volcengine_access_key=self.volcengine_access_key,
-            volcengine_secret_key=self.volcengine_secret_key,
+            volcengine_access_key=volcengine_access_key,
+            volcengine_secret_key=volcengine_secret_key,
+            session_token=session_token,
             method=method,
             data=body,
         )

veadk/memory/long_term_memory.py

@@ -104,6 +104,15 @@ class LongTermMemory(BaseMemoryService, BaseModel):
 
         # Once user define backend config, use it directly
         if self.backend_config:
+            if "index" not in self.backend_config:
+                logger.warning(
+                    "Attribute `index` not provided in backend_config, use `index` or `app_name` instead."
+                )
+                self.backend_config["index"] = self.index or self.app_name
+
+            logger.debug(
+                f"Init {self.backend}, Use provided backend config: {self.backend_config}"
+            )
             self._backend = _get_backend_cls(self.backend)(**self.backend_config)
             return
 

veadk/memory/long_term_memory_backends/vikingdb_memory_backend.py

@@ -49,7 +49,23 @@ class VikingDBLTMBackend(BaseLongTermMemoryBackend):
     region: str = "cn-beijing"
     """VikingDB memory region"""
 
+    memory_type: list[str] = Field(default_factory=list)
+
     def model_post_init(self, __context: Any) -> None:
+        # We get memory type from:
+        # 1. user input
+        # 2. environment variable
+        # 3. default value
+        if not self.memory_type:
+            env_memory_type = os.getenv("DATABASE_VIKINGMEM_MEMORY_TYPE")
+            if env_memory_type:
+                # "event_1, event_2" -> ["event_1", "event_2"]
+                self.memory_type = [x.strip() for x in env_memory_type.split(",")]
+            else:
+                self.memory_type = ["sys_event_v1", "event_v1"]
+
+        logger.info(f"Using memory type: {self.memory_type}")
+
         # check whether collection exist, if not, create it
         if not self._collection_exist():
             self._create_collection()
@@ -68,17 +84,23 @@ class VikingDBLTMBackend(BaseLongTermMemoryBackend):
         try:
             client = self._get_client()
             client.get_collection(collection_name=self.index)
+            logger.info(f"Collection {self.index} exist.")
             return True
         except Exception:
+            logger.info(f"Collection {self.index} not exist.")
             return False
 
     def _create_collection(self) -> None:
+        logger.info(
+            f"Create collection with collection_name={self.index}, builtin_event_types={self.memory_type}"
+        )
         client = self._get_client()
         response = client.create_collection(
             collection_name=self.index,
             description="Created by Volcengine Agent Development Kit VeADK",
-            builtin_event_types=["sys_event_v1"],
+            builtin_event_types=self.memory_type,
         )
+        logger.debug(f"Create collection with response {response}")
         return response
 
     def _get_client(self) -> VikingDBMemoryClient:
@@ -135,10 +157,7 @@ class VikingDBLTMBackend(BaseLongTermMemoryBackend):
     def search_memory(
         self, user_id: str, query: str, top_k: int, **kwargs
     ) -> list[str]:
-        filter = {
-            "user_id": user_id,
-            "memory_type": ["sys_event_v1"],
-        }
+        filter = {"user_id": user_id, "memory_type": self.memory_type}
 
         logger.debug(
             f"Request for search memory in VikingDB: filter={filter}, collection_name={self.index}, query={query}, limit={top_k}"

veadk/tools/builtin_tools/generate_image.py

@@ -33,6 +33,10 @@ from veadk.consts import (
 from veadk.utils.logger import get_logger
 from veadk.utils.misc import formatted_timestamp, read_file_to_bytes
 from veadk.version import VERSION
+import asyncio
+import concurrent.futures
+import contextvars
+
 
 logger = get_logger(__name__)
 
@@ -43,11 +47,164 @@ client = Ark(
     base_url=getenv("MODEL_IMAGE_API_BASE", DEFAULT_IMAGE_GENERATE_MODEL_API_BASE),
 )
 
+executor = concurrent.futures.ThreadPoolExecutor(max_workers=8)
+tracer = trace.get_tracer("gcp.vertex.agent")
 
-async def image_generate(
-    tasks: list,
-    tool_context: ToolContext,
-) -> Dict:
+
+def _build_input_parts(item: dict, task_type: str, image_field):
+    input_part = {"role": "user"}
+    input_part["parts.0.type"] = "text"
+    input_part["parts.0.text"] = json.dumps(item, ensure_ascii=False)
+
+    if image_field:
+        if task_type.startswith("single"):
+            assert isinstance(image_field, str), (
+                f"single_* task_type image must be str, got {type(image_field)}"
+            )
+            input_part["parts.1.type"] = "image_url"
+            input_part["parts.1.image_url.name"] = "origin_image"
+            input_part["parts.1.image_url.url"] = image_field
+        elif task_type.startswith("multi"):
+            assert isinstance(image_field, list), (
+                f"multi_* task_type image must be list, got {type(image_field)}"
+            )
+            assert len(image_field) <= 10, (
+                f"multi_* task_type image list length must be <= 10, got {len(image_field)}"
+            )
+            for i, image_url in enumerate(image_field):
+                idx = i + 1
+                input_part[f"parts.{idx}.type"] = "image_url"
+                input_part[f"parts.{idx}.image_url.name"] = f"origin_image_{i}"
+                input_part[f"parts.{idx}.image_url.url"] = image_url
+
+    return input_part
+
+
+def handle_single_task_sync(
+    idx: int, item: dict, tool_context
+) -> tuple[list[dict], list[str]]:
+    logger.debug(f"handle_single_task_sync item {idx}: {item}")
+    success_list: list[dict] = []
+    error_list: list[str] = []
+    total_tokens = 0
+    output_tokens = 0
+    output_part = {"message.role": "model"}
+
+    task_type = item.get("task_type", "text_to_single")
+    prompt = item.get("prompt", "")
+    response_format = item.get("response_format", None)
+    size = item.get("size", None)
+    watermark = item.get("watermark", None)
+    image_field = item.get("image", None)
+    sequential_image_generation = item.get("sequential_image_generation", None)
+    max_images = item.get("max_images", None)
+
+    input_part = _build_input_parts(item, task_type, image_field)
+
+    inputs = {"prompt": prompt}
+    if size:
+        inputs["size"] = size
+    if response_format:
+        inputs["response_format"] = response_format
+    if watermark is not None:
+        inputs["watermark"] = watermark
+    if sequential_image_generation:
+        inputs["sequential_image_generation"] = sequential_image_generation
+
+    with tracer.start_as_current_span(f"call_llm_task_{idx}") as span:
+        try:
+            if (
+                sequential_image_generation
+                and sequential_image_generation == "auto"
+                and max_images
+            ):
+                response = client.images.generate(
+                    model=getenv("MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME),
+                    **inputs,
+                    sequential_image_generation_options=SequentialImageGenerationOptions(
+                        max_images=max_images
+                    ),
+                )
+            else:
+                response = client.images.generate(
+                    model=getenv("MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME),
+                    **inputs,
+                )
+
+            if not response.error:
+                logger.debug(f"task {idx} Image generate response: {response}")
+
+                total_tokens += getattr(response.usage, "total_tokens", 0) or 0
+                output_tokens += getattr(response.usage, "output_tokens", 0) or 0
+
+                for i, image_data in enumerate(response.data):
+                    image_name = f"task_{idx}_image_{i}"
+                    if "error" in image_data:
+                        logger.error(f"Image {image_name} error: {image_data.error}")
+                        error_list.append(image_name)
+                        continue
+
+                    if getattr(image_data, "url", None):
+                        image_url = image_data.url
+                    else:
+                        b64 = getattr(image_data, "b64_json", None)
+                        if not b64:
+                            logger.error(
+                                f"Image {image_name} missing data (no url/b64)"
+                            )
+                            error_list.append(image_name)
+                            continue
+                        image_bytes = base64.b64decode(b64)
+                        image_url = _upload_image_to_tos(
+                            image_bytes=image_bytes, object_key=f"{image_name}.png"
+                        )
+                        if not image_url:
+                            logger.error(f"Upload image to TOS failed: {image_name}")
+                            error_list.append(image_name)
+                            continue
+                        logger.debug(f"Image saved as ADK artifact: {image_name}")
+
+                    tool_context.state[f"{image_name}_url"] = image_url
+                    output_part[f"message.parts.{i}.type"] = "image_url"
+                    output_part[f"message.parts.{i}.image_url.name"] = image_name
+                    output_part[f"message.parts.{i}.image_url.url"] = image_url
+                    logger.debug(
+                        f"Image {image_name} generated successfully: {image_url}"
+                    )
+                    success_list.append({image_name: image_url})
+            else:
+                logger.error(
+                    f"Task {idx} No images returned by model: {response.error}"
+                )
+                error_list.append(f"task_{idx}")
+
+        except Exception as e:
+            logger.error(f"Error in task {idx}: {e}")
+            traceback.print_exc()
+            error_list.append(f"task_{idx}")
+
+        finally:
+            add_span_attributes(
+                span,
+                tool_context,
+                input_part=input_part,
+                output_part=output_part,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+                request_model=getenv(
+                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                ),
+                response_model=getenv(
+                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                ),
+            )
+    logger.debug(
+        f"task {idx} Image generate success_list: {success_list}\nerror_list: {error_list}"
+    )
+    return success_list, error_list
+
+
+async def image_generate(tasks: list[dict], tool_context) -> Dict:
     """
     Seedream 4.0: batch image generation via tasks.
     Args:
@@ -127,193 +284,72 @@ async def image_generate(
     - 如果想要指定生成组图的数量，请在prompt里添加数量说明，例如："生成3张图片"。
     - size 推荐使用 2048x2048 或表格里的标准比例，确保生成质量。
     """
-
+    logger.debug(
+        f"Using model: {getenv('MODEL_IMAGE_NAME', DEFAULT_IMAGE_GENERATE_MODEL_NAME)}"
+    )
     success_list: list[dict] = []
-    error_list = []
-
-    for idx, item in enumerate(tasks):
-        input_part = {"role": "user"}
-        output_part = {"message.role": "model"}
-        total_tokens = 0
-        output_tokens = 0
-        tracer = trace.get_tracer("gcp.vertex.agent")
-        with tracer.start_as_current_span("call_llm") as span:
-            task_type = item.get("task_type", "text_to_single")
-            prompt = item.get("prompt", "")
-            response_format = item.get("response_format", None)
-            size = item.get("size", None)
-            watermark = item.get("watermark", None)
-            image = item.get("image", None)
-            sequential_image_generation = item.get("sequential_image_generation", None)
-            max_images = item.get("max_images", None)
-
-            input_part["parts.0.type"] = "text"
-            input_part["parts.0.text"] = json.dumps(item, ensure_ascii=False)
-            inputs = {
-                "prompt": prompt,
-            }
-
-            if size:
-                inputs["size"] = size
-            if response_format:
-                inputs["response_format"] = response_format
-            if watermark:
-                inputs["watermark"] = watermark
-            if image:
-                if task_type.startswith("single"):
-                    assert isinstance(image, str), (
-                        f"single_* task_type image must be str, got {type(image)}"
-                    )
-                    input_part["parts.1.type"] = "image_url"
-                    input_part["parts.1.image_url.name"] = "origin_image"
-                    input_part["parts.1.image_url.url"] = image
-                elif task_type.startswith("multi"):
-                    assert isinstance(image, list), (
-                        f"multi_* task_type image must be list, got {type(image)}"
-                    )
-                    assert len(image) <= 10, (
-                        f"multi_* task_type image list length must be <= 10, got {len(image)}"
-                    )
-                    for i, image_url in enumerate(image):
-                        input_part[f"parts.{i + 1}.type"] = "image_url"
-                        input_part[f"parts.{i + 1}.image_url.name"] = (
-                            f"origin_image_{i}"
-                        )
-                        input_part[f"parts.{i + 1}.image_url.url"] = image_url
-
-            if sequential_image_generation:
-                inputs["sequential_image_generation"] = sequential_image_generation
-
-            try:
-                if (
-                    sequential_image_generation
-                    and sequential_image_generation == "auto"
-                    and max_images
-                ):
-                    response = client.images.generate(
-                        model=getenv(
-                            "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
-                        ),
-                        **inputs,
-                        sequential_image_generation_options=SequentialImageGenerationOptions(
-                            max_images=max_images
-                        ),
-                    )
-                else:
-                    response = client.images.generate(
-                        model=getenv(
-                            "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
-                        ),
-                        **inputs,
-                    )
-                if not response.error:
-                    for i, image_data in enumerate(response.data):
-                        image_name = f"task_{idx}_image_{i}"
-                        if "error" in image_data:
-                            error_details = (
-                                f"Image {image_name} error: {image_data.error}"
-                            )
-                            logger.error(error_details)
-                            error_list.append(image_name)
-                            continue
-                        if image_data.url:
-                            image = image_data.url
-                            tool_context.state[f"{image_name}_url"] = image
-
-                            output_part[f"message.parts.{i}.type"] = "image_url"
-                            output_part[f"message.parts.{i}.image_url.name"] = (
-                                image_name
-                            )
-                            output_part[f"message.parts.{i}.image_url.url"] = image
-
-                        else:
-                            image = image_data.b64_json
-                            image_bytes = base64.b64decode(image)
-
-                            tos_url = _upload_image_to_tos(
-                                image_bytes=image_bytes, object_key=f"{image_name}.png"
-                            )
-                            if tos_url:
-                                tool_context.state[f"{image_name}_url"] = tos_url
-                                image = tos_url
-                                output_part[f"message.parts.{i}.type"] = "image_url"
-                                output_part[f"message.parts.{i}.image_url.name"] = (
-                                    image_name
-                                )
-                                output_part[f"message.parts.{i}.image_url.url"] = image
-                            else:
-                                logger.error(
-                                    f"Upload image to TOS failed: {image_name}"
-                                )
-                                error_list.append(image_name)
-                                continue
-
-                            logger.debug(f"Image saved as ADK artifact: {image_name}")
-
-                        total_tokens += response.usage.total_tokens
-                        output_tokens += response.usage.output_tokens
-                        success_list.append({image_name: image})
-                else:
-                    error_details = (
-                        f"No images returned by Doubao model: {response.error}"
-                    )
-                    logger.error(error_details)
-                    error_list.append(f"task_{idx}")
-
-            except Exception as e:
-                error_details = f"Error: {e}"
-                logger.error(error_details)
-                traceback.print_exc()
-                error_list.append(f"task_{idx}")
-
-            add_span_attributes(
-                span,
-                tool_context,
-                input_part=input_part,
-                output_part=output_part,
-                output_tokens=output_tokens,
-                total_tokens=total_tokens,
-                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:
+    error_list: list[str] = []
+    logger.debug(f"image_generate tasks: {tasks}")
+    with tracer.start_as_current_span("image_generate"):
+        base_ctx = contextvars.copy_context()
+
+        def make_task(idx, item):
+            ctx = base_ctx.copy()
+            return lambda: ctx.run(handle_single_task_sync, idx, item, tool_context)
+
+        loop = asyncio.get_event_loop()
+        futures = [
+            loop.run_in_executor(executor, make_task(idx, item))
+            for idx, item in enumerate(tasks)
+        ]
+
+        results = await asyncio.gather(*futures, return_exceptions=True)
+
+        for res in results:
+            if isinstance(res, Exception):
+                logger.error(f"Task raised exception: {res}")
+                error_list.append("unknown_task_exception")
+                continue
+            s, e = res
+            success_list.extend(s)
+            error_list.extend(e)
+
+    if not success_list:
+        logger.debug(
+            f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "error",
             "success_list": success_list,
             "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
+    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_file_to_bytes(image_tos_url),
+                            mime_type=mimetypes.guess_type(image_tos_url)[0],
+                        )
+                    ),
+                )
 
-        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_file_to_bytes(image_tos_url),
-                                mime_type=mimetypes.guess_type(image_tos_url)[0],
-                            )
-                        ),
-                    )
-        return {
-            "status": "success",
-            "success_list": success_list,
-            "error_list": error_list,
-        }
+    logger.debug(
+        f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+    )
+    return {"status": "success", "success_list": success_list, "error_list": error_list}
 
 
 def add_span_attributes(

veadk/tools/builtin_tools/image_edit.py

@@ -97,9 +97,14 @@ async def image_edit(
         - Provide the same `seed` for consistent outputs across runs.
         - A high `guidance_scale` enforces stricter adherence to text prompt.
     """
+    logger.debug(
+        f"Using model: {getenv('MODEL_EDIT_NAME', DEFAULT_IMAGE_EDIT_MODEL_NAME)}"
+    )
     success_list = []
     error_list = []
+    logger.debug(f"image_edit params: {params}")
     for idx, item in enumerate(params):
+        logger.debug(f"image_edit item {idx}: {item}")
         image_name = item.get("image_name", f"generated_image_{idx}")
         prompt = item.get("prompt")
         origin_image = item.get("origin_image")
@@ -133,6 +138,7 @@ async def image_edit(
                 )
                 output_part = None
                 if response.data and len(response.data) > 0:
+                    logger.debug(f"task {idx} Image edit response: {response}")
                     for item in response.data:
                         if response_format == "url":
                             image = item.url
@@ -167,7 +173,9 @@ async def image_edit(
                                 continue
 
                             logger.debug(f"Image saved as ADK artifact: {image_name}")
-
+                        logger.debug(
+                            f"Image {image_name} generated successfully: {image}"
+                        )
                         success_list.append({image_name: image})
                 else:
                     error_details = f"No images returned by Doubao model: {response}"
@@ -196,12 +204,18 @@ async def image_edit(
             error_list.append(image_name)
 
     if len(success_list) == 0:
+        logger.debug(
+            f"image_edit success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "error",
             "success_list": success_list,
             "error_list": error_list,
         }
     else:
+        logger.debug(
+            f"image_edit success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "success",
             "success_list": success_list,

veadk/tools/builtin_tools/image_generate.py

@@ -98,9 +98,14 @@ async def image_generate(
         - Use a fixed `seed` for reproducibility.
         - Choose appropriate `size` for desired aspect ratio.
     """
+    logger.debug(
+        f"Using model: {getenv('MODEL_IMAGE_NAME', DEFAULT_TEXT_TO_IMAGE_MODEL_NAME)}"
+    )
     success_list = []
     error_list = []
+    logger.debug(f"image_generate params: {params}")
     for idx, item in enumerate(params):
+        logger.debug(f"image_generate item {idx}: {item}")
         prompt = item.get("prompt", "")
         image_name = item.get("image_name", f"generated_image_{idx}")
         response_format = item.get("response_format", "url")
@@ -130,6 +135,7 @@ async def image_generate(
                 )
                 output_part = None
                 if response.data and len(response.data) > 0:
+                    logger.debug(f"task {idx} Image generate response: {response}")
                     for item in response.data:
                         if response_format == "url":
                             image = item.url
@@ -164,7 +170,9 @@ async def image_generate(
                                 continue
 
                             logger.debug(f"Image saved as ADK artifact: {image_name}")
-
+                        logger.debug(
+                            f"Image {image_name} generated successfully: {image}"
+                        )
                         success_list.append({image_name: image})
                 else:
                     error_details = f"No images returned by Doubao model: {response}"
@@ -192,12 +200,18 @@ async def image_generate(
             error_list.append(image_name)
 
     if len(success_list) == 0:
+        logger.debug(
+            f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "error",
             "success_list": success_list,
             "error_list": error_list,
         }
     else:
+        logger.debug(
+            f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "success",
             "success_list": success_list,

veadk/tools/builtin_tools/run_code.py

@@ -0,0 +1,81 @@
+# 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 google.adk.tools import ToolContext
+
+from veadk.config import getenv
+from veadk.utils.logger import get_logger
+from veadk.utils.volcengine_sign import ve_request
+
+logger = get_logger(__name__)
+
+
+def run_code(code: str, language: str, tool_context: ToolContext) -> str:
+    """Run code in a code sandbox and return the output.
+
+    Args:
+        code (str): The code to run.
+        language (str): The programming language of the code. Language must be one of the supported languages: python3.
+
+    Returns:
+        str: The output of the code execution.
+    """
+
+    tool_id = getenv("AGENTKIT_TOOL_ID")
+    host = getenv("AGENTKIT_TOOL_HOST")  # temporary host for code run tool
+    service = getenv(
+        "AGENTKIT_TOOL_SERVICE_CODE"
+    )  # temporary service for code run tool
+    region = getenv("AGENTKIT_TOOL_REGION", "cn-beijing")
+
+    session_id = tool_context._invocation_context.session.id
+
+    logger.debug(
+        f"Running code in language: {language}, session_id={session_id}, code={code}, tool_id={tool_id}, host={host}, service={service}, region={region}"
+    )
+
+    access_key = getenv("VOLCENGINE_ACCESS_KEY")
+    secret_key = getenv("VOLCENGINE_SECRET_KEY")
+
+    res = ve_request(
+        request_body={
+            "ToolId": tool_id,
+            "UserSessionId": session_id,
+            "OperationType": "RunCode",
+            "OperationPayload": json.dumps(
+                {
+                    "code": code,
+                    "timeout": 30,
+                    "kernel_name": language,
+                }
+            ),
+        },
+        action="InvokeTool",
+        ak=access_key,
+        sk=secret_key,
+        service=service,
+        version="2025-10-30",
+        region=region,
+        host=host,
+    )
+
+    logger.debug(f"Invoke run code response: {res}")
+
+    try:
+        return res["Result"]["Result"]
+    except KeyError as e:
+        logger.error(f"Error occurred while running code: {e}, response is {res}")
+        return res

veadk/tools/builtin_tools/video_generate.py

@@ -43,7 +43,6 @@ client = Ark(
 async def generate(prompt, first_frame_image=None, last_frame_image=None):
     try:
         if first_frame_image is None:
-            logger.debug("text generation")
             response = client.content_generation.tasks.create(
                 model=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=[
@@ -51,7 +50,6 @@ 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=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=cast(
@@ -66,7 +64,6 @@ 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=getenv("MODEL_VIDEO_NAME", DEFAULT_VIDEO_MODEL_NAME),
                 content=[
@@ -197,9 +194,13 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
     batch_size = 10
     success_list = []
     error_list = []
+    logger.debug(f"Using model: {getenv('MODEL_VIDEO_NAME', DEFAULT_VIDEO_MODEL_NAME)}")
+    logger.debug(f"video_generate params: {params}")
 
     for start_idx in range(0, len(params), batch_size):
         batch = params[start_idx : start_idx + batch_size]
+        logger.debug(f"video_generate batch {start_idx // batch_size}: {batch}")
+
         task_dict = {}
         tracer = trace.get_tracer("gcp.vertex.agent")
         with tracer.start_as_current_span("call_llm") as span:
@@ -216,15 +217,30 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
                 last_frame = item.get("last_frame", None)
                 try:
                     if not first_frame:
+                        logger.debug(
+                            f"video_generate task_{idx} text generation: prompt={prompt}"
+                        )
                         response = await generate(prompt)
                     elif not last_frame:
+                        logger.debug(
+                            f"video_generate task_{idx} first frame generation: prompt={prompt}, first_frame={first_frame}"
+                        )
                         response = await generate(prompt, first_frame)
                     else:
+                        logger.debug(
+                            f"video_generate task_{idx} first and last frame generation: prompt={prompt}, first_frame={first_frame}, last_frame={last_frame}"
+                        )
                         response = await generate(prompt, first_frame, last_frame)
+                    logger.debug(
+                        f"batch_{start_idx // batch_size} video_generate task_{idx} response: {response}"
+                    )
                     task_dict[response.id] = video_name
                 except Exception as e:
                     logger.error(f"Error: {e}")
                     error_list.append(video_name)
+                    continue
+
+            logger.debug("begin query video_generate task status...")
 
             while True:
                 task_list = list(task_dict.keys())
@@ -234,7 +250,9 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
                     result = client.content_generation.tasks.get(task_id=task_id)
                     status = result.status
                     if status == "succeeded":
-                        logger.debug("----- task succeeded -----")
+                        logger.debug(
+                            f"{task_dict[task_id]} video_generate {status}. Video URL: {result.content.video_url}"
+                        )
                         tool_context.state[f"{task_dict[task_id]}_video_url"] = (
                             result.content.video_url
                         )
@@ -248,13 +266,14 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
                         )
                         task_dict.pop(task_id, None)
                     elif status == "failed":
-                        logger.error("----- task failed -----")
-                        logger.error(f"Error: {result.error}")
+                        logger.error(
+                            f"{task_dict[task_id]} video_generate {status}. Error: {result.error}"
+                        )
                         error_list.append(task_dict[task_id])
                         task_dict.pop(task_id, None)
                     else:
                         logger.debug(
-                            f"Current status: {status}, Retrying after 10 seconds..."
+                            f"{task_dict[task_id]} video_generate current status: {status}, Retrying after 10 seconds..."
                         )
                 time.sleep(10)
 
@@ -270,12 +289,18 @@ async def video_generate(params: list, tool_context: ToolContext) -> Dict:
             )
 
     if len(success_list) == 0:
+        logger.debug(
+            f"video_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "error",
             "success_list": success_list,
             "error_list": error_list,
         }
     else:
+        logger.debug(
+            f"video_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "success",
             "success_list": success_list,

veadk/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION = "0.2.11"
+VERSION = "0.2.13"

{veadk_python-0.2.11.dist-info → veadk_python-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veadk-python
-Version: 0.2.11
+Version: 0.2.13
 Summary: Volcengine agent development kit, integrations with Volcengine cloud services.
 Author-email: Yaozheng Fang <fangyozheng@gmail.com>, Guodong Li <cu.eric.lee@gmail.com>, Zhi Han <sliverydayday@gmail.com>, Meng Wang <mengwangwm@gmail.com>
 License:                                  Apache License

{veadk_python-0.2.11.dist-info → veadk_python-0.2.13.dist-info}/RECORD

@@ -5,7 +5,7 @@ veadk/config.py,sha256=Ezl9Lna9iriC_Uf7m1ZXTWzylLyd7YspUFAQqh94Ong,3203
 veadk/consts.py,sha256=LTl4NQYJf7C8EvconGa96NRschzZZmmOqxlEikJe2Nk,2831
 veadk/runner.py,sha256=_DGNwX-t3sHJFJvHs-rRHXbjCZza8I_zU8AN3Fw5nRY,14217
 veadk/types.py,sha256=zOOzG-QJy-MkzHeicWJzy2_L5U4ERrWziPubIUEbd8c,1656
-veadk/version.py,sha256=lWn0jlNA7mzOxPAG6V2hGLZtLsCq9qTpu_I9qSsNO6k,654
+veadk/version.py,sha256=verJVWp2IHUGhnn0kH5_-upx08hfZiViE_fI27Xhh4A,654
 veadk/a2a/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 veadk/a2a/agent_card.py,sha256=lhtgW1acMpxYUdULHEZwVFXOi6Xh4lNkf4S7QIhbFFI,1525
 veadk/a2a/remote_ve_agent.py,sha256=L2nzT8PlDI-lLtcaTJqk-D2Uvw9beKl8OEUqp-8qCbA,3510
@@ -28,14 +28,15 @@ veadk/auth/veauth/prompt_pilot_veauth.py,sha256=cls1LK2Un4cOMfHdaAqRhDHIXuk7cTuA
 veadk/auth/veauth/utils.py,sha256=cVEKWQZeX5fzx3JLB1odv59D8lhOAF1Pb3rsgO6evmM,2152
 veadk/auth/veauth/vesearch_veauth.py,sha256=rgup3VBbRSLligrsDFOEwpneq1BEtFwf9xpgNFWHKqc,2008
 veadk/cli/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
-veadk/cli/cli.py,sha256=lT2VGY8Mn-_eLO5ifsF7vKTW-qgiCJFDve5nc8N_YuQ,1343
+veadk/cli/cli.py,sha256=-IGJKG9bGZpZXdLirOHv0LlpN9Vo42qzeEyNnZKsKv8,1430
 veadk/cli/cli_deploy.py,sha256=-P4PmXLGByypXGksshBT7BQ0U42hIvlHibXd_k4YfhQ,5328
 veadk/cli/cli_eval.py,sha256=TVSraCTyTxo_pLu5fhtk3TiZUOZkN3G2BLam1ybFXBc,5446
 veadk/cli/cli_init.py,sha256=f2A3RwUj9pApmUTl6FHmMwTTwyKl83pkvZRorTgl-XM,3982
 veadk/cli/cli_kb.py,sha256=SmLz3g6o2LiPa6WzkdyAOExuboHkpAIrN-4qaH4rxn8,1962
 veadk/cli/cli_pipeline.py,sha256=6FV4WyoapFPAy_P3dzrRm07m6aGjrtLiY4aCFT7CEHs,7510
 veadk/cli/cli_prompt.py,sha256=atw6O3zkjD1tOsFOOg7rs9HbS4exwaNe_Pces6CoyFY,2582
-veadk/cli/cli_web.py,sha256=20VwLxsLf060Gca31Pw3NH5KX9W88sIvgiPECDvY6_4,6246
+veadk/cli/cli_uploadevalset.py,sha256=RdelvbXEBalXGxHnPJ-8ZQ1PRiex39328yhAWgZ5mAI,4342
+veadk/cli/cli_web.py,sha256=wPuLoG57s3E3GOQQ7wnDJ923LgIEG4pcO_pNjkd9ynE,6732
 veadk/cloud/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 veadk/cloud/cloud_agent_engine.py,sha256=u-v-kkAhRgZY1r82CQRwfkYnj0n7ft8qIW_r-yhnMSI,8461
 veadk/cloud/cloud_app.py,sha256=2bmEf7RH1Kwz8HLZ0aY3pVn0R8xi1T7kcGRTRyaWawY,8746
@@ -104,7 +105,7 @@ veadk/integrations/ve_prompt_pilot/ve_prompt_pilot.py,sha256=Wp16pejFObnfudzNv1A
 veadk/integrations/ve_tls/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 veadk/integrations/ve_tls/utils.py,sha256=DmWS37gSuKsUgiqlLyk1obfAAZZnEpkemQuoTDxAEG4,3769
 veadk/integrations/ve_tls/ve_tls.py,sha256=zO8rSX0CqxcjKjosXI90ykNFO6dhpsIsPa9uZGrf50s,7253
-veadk/integrations/ve_tos/ve_tos.py,sha256=yjc3h6JH2MM_8InE42YqjZupu5pcfFwHAMqPhr3x544,25186
+veadk/integrations/ve_tos/ve_tos.py,sha256=8tWb-eO7IK140VwjI-Bl4LNCeQNI9CgvKsr9gLXe5aA,25365
 veadk/integrations/ve_viking_db_memory/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 veadk/integrations/ve_viking_db_memory/ve_viking_db_memory.py,sha256=gX5asox3VDra6o1BIg7AickPec0-Vj8_lgZ1zz5ue5Y,10165
 veadk/knowledgebase/__init__.py,sha256=k-5WM0DAqNq94Dg64Rl12ozoS1BnE9i-MY_ZOR2s2CQ,705
@@ -115,10 +116,10 @@ veadk/knowledgebase/backends/base_backend.py,sha256=gqkJNIASc-ZrJ2e4enIeUvI9CWuc
 veadk/knowledgebase/backends/in_memory_backend.py,sha256=uC4_LCkjp9DFQzTgTKzEr6yw1hcNUpZ0h7WSR0fpifc,3332
 veadk/knowledgebase/backends/opensearch_backend.py,sha256=4oChkqd25RvL460p1-D7noxQIoZVlD03aB61pKREqNw,4953
 veadk/knowledgebase/backends/redis_backend.py,sha256=pc-T_QicyAmOp6KbMz0V8iIL1ZlKCKQpdNB9SkaNqm8,5226
-veadk/knowledgebase/backends/utils.py,sha256=GOIuOFIJqruIk5Imx4F7ou5qKTUmg_gWJoLYi1kkopQ,2661
-veadk/knowledgebase/backends/vikingdb_knowledge_backend.py,sha256=hVSfAc17wzEoEKlPa7x3ekCcApFgDzY7x6ceBDxd9mw,18126
+veadk/knowledgebase/backends/utils.py,sha256=383La0fsmPcbJEpGWk54EP8p8QO1SP_ThqJPmRWa5Rs,2705
+veadk/knowledgebase/backends/vikingdb_knowledge_backend.py,sha256=khk33XDDdeK1tb84lHtTAjtuZQLmubZFo3shyd70YLs,19245
 veadk/memory/__init__.py,sha256=GRIoRqapS2gUtRMB9JZvodU29PwMxFe2KDjPnVpqib0,1252
-veadk/memory/long_term_memory.py,sha256=YE5DH9qyJwlA7t0smwV4J90wnUBYVR6MRXHg1qsqKNU,7423
+veadk/memory/long_term_memory.py,sha256=122uacyNsKkUIfsc5Vru8lMGsJKE0A7JJqddLaxX-ls,7838
 veadk/memory/short_term_memory.py,sha256=MLR2Op_l_Zr-ZKCJ7pyNhe_OzPG06Zcb8pt8qA_zrFY,4922
 veadk/memory/short_term_memory_processor.py,sha256=vqmYSUNFGXEogJ8ZxIAhSSrv66LGT8eEHCzxF9h07LA,3276
 veadk/memory/long_term_memory_backends/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
@@ -127,7 +128,7 @@ veadk/memory/long_term_memory_backends/in_memory_backend.py,sha256=0IKRqstS3Rtm8
 veadk/memory/long_term_memory_backends/mem0_backend.py,sha256=sj6OxMHA4oG6kuzTMK5zsGEIIa0-ESPrRYv6dR3KI8E,4869
 veadk/memory/long_term_memory_backends/opensearch_backend.py,sha256=u5odPUv0fchH3IsZNTH0-nNpdW4KwkWojRQi3cn52Wo,4567
 veadk/memory/long_term_memory_backends/redis_backend.py,sha256=0XX21AJA4UwEqrteXdgOr5WAfuo31wK1fMLUtXMssfg,5262
-veadk/memory/long_term_memory_backends/vikingdb_memory_backend.py,sha256=QSSy6edP9zWrKTUcnZ8MsPhCcQJmL0IJzGeLxuY0BGo,5781
+veadk/memory/long_term_memory_backends/vikingdb_memory_backend.py,sha256=TfAtQXiJ-iZLRKPTBMakQTwRoHdDsN0l2R5udNFJatY,6683
 veadk/memory/short_term_memory_backends/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 veadk/memory/short_term_memory_backends/base_backend.py,sha256=5AtnWuFE_TYpTAlAKnm2xglf4AT3iXmU9QSF7LkO1BA,1053
 veadk/memory/short_term_memory_backends/mysql_backend.py,sha256=_m-yuB7X-pPvs93-W8ZswDIkIpYpCFMRRdt9D5SZzn8,1513
@@ -142,15 +143,16 @@ veadk/tools/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 veadk/tools/demo_tools.py,sha256=Gu3sxygcYVS2cv3WqUOl-Gq4JhMlDAktoCHOFT0gbFQ,2216
 veadk/tools/load_knowledgebase_tool.py,sha256=UUTv0Za9GkEXAkl1SXmyq0HGCKGvSlH_f8Ok6O6e52M,4704
 veadk/tools/builtin_tools/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
-veadk/tools/builtin_tools/generate_image.py,sha256=BksUf1sEFDzOkDAPOlmtfALKGAtVSfbMC_WY33uCyaM,16701
-veadk/tools/builtin_tools/image_edit.py,sha256=Nv9nAbW_0zovR_lyZe2A3PIN6Dlifm5jN8PTWRULf9M,10926
-veadk/tools/builtin_tools/image_generate.py,sha256=PCnq16qj28UsauShLmVSSnC91HQMWC0rhFdSfPR0Ko4,10671
+veadk/tools/builtin_tools/generate_image.py,sha256=aDMlR-IrxUMepIl9hPkywlH-4e7uIRiyFzLTtmezOnw,17495
+veadk/tools/builtin_tools/image_edit.py,sha256=KslsuabBchAYR3ZrWSO5viEe5ORUAe0GI1qQ6mxoIU0,11588
+veadk/tools/builtin_tools/image_generate.py,sha256=-L_3k3KRJ_arljLfKz946fbd9ppxTDNvJmkNGhgj6qQ,11357
 veadk/tools/builtin_tools/lark.py,sha256=b2IWsN8fZFh9aweSGznaOqA30TCOLpVjNCDNa1LHZl4,2046
 veadk/tools/builtin_tools/las.py,sha256=rgKfnK5GsHVbmkp-rc7rtCvWg-yYNxMjeV0ayCyRpjM,913
 veadk/tools/builtin_tools/load_knowledgebase.py,sha256=Xqtq25DL720goRegCVmmkpH2Ye2VWLcrF5ncC37gK_Y,3427
 veadk/tools/builtin_tools/mcp_router.py,sha256=l3xcIHAHQ0AGCZG3mYyhwM0btqEMDe4TY2S-UYUM8M0,883
+veadk/tools/builtin_tools/run_code.py,sha256=C2CRMNZYgKoyVpe4JoGtUa-Xfb48IuyNIHzF5WKJfxw,2623
 veadk/tools/builtin_tools/vesearch.py,sha256=prPP0w6lYeIEPwuZdmV00RAzaW4MeH8lYtK-NluaXtU,1748
-veadk/tools/builtin_tools/video_generate.py,sha256=8uozyhmg203vpI2mXSkSji79WFZ2B0IzFMLTIGVzc2M,14778
+veadk/tools/builtin_tools/video_generate.py,sha256=hlvwoLESUV8vOPiNFVNPF0ithWqH7N5c6ElMvyI-lBM,16101
 veadk/tools/builtin_tools/web_scraper.py,sha256=iVnxWVf2mVgOnEOeQ6Bg5ATYN-g1ZPCTK6VJm710be0,2408
 veadk/tools/builtin_tools/web_search.py,sha256=1DtdhlcxolzIvx2TyqvUNWk60BHMuLkcru8Wlw3XBtQ,6016
 veadk/tools/sandbox/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
@@ -179,9 +181,9 @@ veadk/utils/mcp_utils.py,sha256=aET7pX3LXmRe2-Jh7_xRvxrVyl1dN7uPAUk16luwMlQ,1525
 veadk/utils/misc.py,sha256=ghEqrqoDfKrW9ZD3IB0bwcfyyB0gRWN2yEP9eRxQ4nE,4953
 veadk/utils/patches.py,sha256=dcHdlJ8IciyMjDuMy6-_6McUqJYyLz0yHmJ0xH8lWOw,2752
 veadk/utils/volcengine_sign.py,sha256=3xn6ca2OAg_AFyP2dqFTSioqkeDel_BoKURUtCcO-EQ,6736
-veadk_python-0.2.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-veadk_python-0.2.11.dist-info/METADATA,sha256=efOOpg8g2B2DWlBQ9xJhvMRHCkCWmQaX1njAolmkHiw,18428
-veadk_python-0.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-veadk_python-0.2.11.dist-info/entry_points.txt,sha256=-g28D6dNV-2UvAiRP9VF0oOVSDSJ5zlLUIZ34ArAqF8,46
-veadk_python-0.2.11.dist-info/top_level.txt,sha256=Qqi3ycJ4anKiZWBXtUBIy8zK9ZuXJsFa05oFq8O8qqY,6
-veadk_python-0.2.11.dist-info/RECORD,,
+veadk_python-0.2.13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+veadk_python-0.2.13.dist-info/METADATA,sha256=xonF3Utpt7sSjF-2uewm1laDYbSrgbDeiX9dEqwb_pM,18428
+veadk_python-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+veadk_python-0.2.13.dist-info/entry_points.txt,sha256=-g28D6dNV-2UvAiRP9VF0oOVSDSJ5zlLUIZ34ArAqF8,46
+veadk_python-0.2.13.dist-info/top_level.txt,sha256=Qqi3ycJ4anKiZWBXtUBIy8zK9ZuXJsFa05oFq8O8qqY,6
+veadk_python-0.2.13.dist-info/RECORD,,