veadk-python 0.2.4__tar.gz → 0.2.5__tar.gz

{veadk_python-0.2.4 → veadk_python-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veadk-python
-Version: 0.2.4
+Version: 0.2.5
 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.4 → veadk_python-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "veadk-python"
-version = "0.2.4"
+version = "0.2.5"
 description = "Volcengine agent development kit, integrations with Volcengine cloud services."
 readme = "README.md"
 requires-python = ">=3.10"

{veadk_python-0.2.4 → veadk_python-0.2.5}/tests/test_agent.py

@@ -15,6 +15,7 @@
 from google.adk.tools import load_memory
 
 from veadk import Agent
+from veadk.consts import DEFAULT_MODEL_EXTRA_HEADERS
 from veadk.knowledgebase import KnowledgeBase
 from veadk.memory.long_term_memory import LongTermMemory
 from veadk.tools import load_knowledgebase_tool
@@ -26,11 +27,14 @@ def test_agent():
     long_term_memory = LongTermMemory(backend="local")
     tracer = OpentelemetryTracer()
 
+    model_extra_headers = {"test-header": "test-value"}
+
     agent = Agent(
         model_name="test_model_name",
         model_provider="test_model_provider",
         model_api_key="test_model_api_key",
         model_api_base="test_model_api_base",
+        model_extra_headers=model_extra_headers,
         tools=[],
         sub_agents=[],
         knowledgebase=knowledgebase,
@@ -39,7 +43,10 @@ def test_agent():
         serve_url="",
     )
 
+    model_extra_headers |= DEFAULT_MODEL_EXTRA_HEADERS
+
     assert agent.model.model == f"{agent.model_provider}/{agent.model_name}"
+    assert agent.model_extra_headers == model_extra_headers
 
     assert agent.knowledgebase == knowledgebase
     assert agent.knowledgebase.backend == "local"

{veadk_python-0.2.4 → veadk_python-0.2.5}/tests/test_cloud.py

@@ -115,9 +115,12 @@ async def test_cloud():
                         mock_vefaas_client = Mock()
                         mock_vefaas_in_app.return_value = mock_vefaas_client
                         mock_vefaas_client.delete.return_value = None
-
-                        cloud_app.delete_self()
-                        mock_vefaas_client.delete.assert_called_with("app-123")
+                        with patch.object(
+                            cloud_app, "_get_vefaas_application_id_by_name"
+                        ) as mock_get_id_by_name:
+                            mock_get_id_by_name.return_value = None
+                            cloud_app.delete_self()
+                            mock_vefaas_client.delete.assert_called_with("app-123")
 
                 # Verify all mocks were called as expected
                 mock_vefaas_service.deploy.assert_called_once()

{veadk_python-0.2.4 → veadk_python-0.2.5}/tests/test_runner.py

@@ -28,7 +28,7 @@ def _test_convert_messages(runner):
             role="user",
         )
     ]
-    actual_message = runner._convert_messages(message)
+    actual_message = runner._convert_messages(message, session_id="test_session_id")
     assert actual_message == expected_message
 
     message = ["test message 1", "test message 2"]
@@ -42,7 +42,7 @@ def _test_convert_messages(runner):
             role="user",
         ),
     ]
-    actual_message = runner._convert_messages(message)
+    actual_message = runner._convert_messages(message, session_id="test_session_id")
     assert actual_message == expected_message
 
 

veadk_python-0.2.5/tests/test_tos.py

@@ -0,0 +1,110 @@
+# 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 pytest
+from unittest import mock
+import veadk.integrations.ve_tos.ve_tos as tos_mod
+
+# 使用 pytest-asyncio
+pytest_plugins = ("pytest_asyncio",)
+
+
+@pytest.fixture
+def mock_client(monkeypatch):
+    fake_client = mock.Mock()
+
+    monkeypatch.setenv("DATABASE_TOS_REGION", "test-region")
+    monkeypatch.setenv("VOLCENGINE_ACCESS_KEY", "test-access-key")
+    monkeypatch.setenv("VOLCENGINE_SECRET_KEY", "test-secret-key")
+    monkeypatch.setenv("DATABASE_TOS_BUCKET", "test-bucket")
+
+    monkeypatch.setattr(tos_mod.tos, "TosClientV2", lambda *a, **k: fake_client)
+
+    class FakeExceptions:
+        class TosServerError(Exception):
+            def __init__(self, msg):
+                super().__init__(msg)
+                self.status_code = None
+
+    monkeypatch.setattr(tos_mod.tos, "exceptions", FakeExceptions)
+    monkeypatch.setattr(
+        tos_mod.tos,
+        "StorageClassType",
+        type("S", (), {"Storage_Class_Standard": "STANDARD"}),
+    )
+    monkeypatch.setattr(
+        tos_mod.tos, "ACLType", type("A", (), {"ACL_Private": "private"})
+    )
+
+    return fake_client
+
+
+@pytest.fixture
+def tos_client(mock_client):
+    return tos_mod.VeTOS()
+
+
+def test_create_bucket_exists(tos_client, mock_client):
+    mock_client.head_bucket.return_value = None  # head_bucket 正常返回表示存在
+    result = tos_client.create_bucket()
+    assert result is True
+    mock_client.create_bucket.assert_not_called()
+
+
+def test_create_bucket_not_exists(tos_client, mock_client):
+    exc = tos_mod.tos.exceptions.TosServerError("not found")
+    exc.status_code = 404
+    mock_client.head_bucket.side_effect = exc
+
+    result = tos_client.create_bucket()
+    assert result is True
+    mock_client.create_bucket.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_upload_bytes_success(tos_client, mock_client):
+    mock_client.head_bucket.return_value = True
+    data = b"hello world"
+
+    result = await tos_client.upload("obj-key", data)
+    assert result is True
+    mock_client.put_object.assert_called_once()
+    mock_client.close.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_upload_file_success(tmp_path, tos_client, mock_client):
+    mock_client.head_bucket.return_value = True
+    file_path = tmp_path / "file.txt"
+    file_path.write_text("hello file")
+
+    result = await tos_client.upload("obj-key", str(file_path))
+    assert result is True
+    mock_client.put_object_from_file.assert_called_once()
+    mock_client.close.assert_called_once()
+
+
+def test_download_success(tmp_path, tos_client, mock_client):
+    save_path = tmp_path / "out.txt"
+    mock_client.get_object.return_value = [b"abc", b"def"]
+
+    result = tos_client.download("obj-key", str(save_path))
+    assert result is True
+    assert save_path.read_bytes() == b"abcdef"
+
+
+def test_download_fail(tos_client, mock_client):
+    mock_client.get_object.side_effect = Exception("boom")
+    result = tos_client.download("obj-key", "somewhere.txt")
+    assert result is False

{veadk_python-0.2.4 → veadk_python-0.2.5}/veadk/agent.py

@@ -28,9 +28,10 @@ from typing_extensions import Any
 
 from veadk.config import getenv
 from veadk.consts import (
-    DEFALUT_MODEL_AGENT_PROVIDER,
+    DEFAULT_MODEL_AGENT_PROVIDER,
     DEFAULT_MODEL_AGENT_API_BASE,
     DEFAULT_MODEL_AGENT_NAME,
+    DEFAULT_MODEL_EXTRA_HEADERS,
 )
 from veadk.evaluation import EvalSetRecorder
 from veadk.knowledgebase import KnowledgeBase
@@ -64,7 +65,7 @@ class Agent(LlmAgent):
     model_name: str = getenv("MODEL_AGENT_NAME", DEFAULT_MODEL_AGENT_NAME)
     """The name of the model for agent running."""
 
-    model_provider: str = getenv("MODEL_AGENT_PROVIDER", DEFALUT_MODEL_AGENT_PROVIDER)
+    model_provider: str = getenv("MODEL_AGENT_PROVIDER", DEFAULT_MODEL_AGENT_PROVIDER)
     """The provider of the model for agent running."""
 
     model_api_base: str = getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE)
@@ -73,6 +74,9 @@ class Agent(LlmAgent):
     model_api_key: str = Field(default_factory=lambda: getenv("MODEL_AGENT_API_KEY"))
     """The api key of the model for agent running."""
 
+    model_extra_config: dict = Field(default_factory=dict)
+    """The extra config to include in the model requests."""
+
     tools: list[ToolUnion] = []
     """The tools provided to agent."""
 
@@ -96,11 +100,27 @@ class Agent(LlmAgent):
 
     def model_post_init(self, __context: Any) -> None:
         super().model_post_init(None)  # for sub_agents init
-        self.model = LiteLlm(
-            model=f"{self.model_provider}/{self.model_name}",
-            api_key=self.model_api_key,
-            api_base=self.model_api_base,
-        )
+
+        # add model request source (veadk) in extra headers
+        if self.model_extra_config and "extra_headers" in self.model_extra_config:
+            self.model_extra_config["extra_headers"] |= DEFAULT_MODEL_EXTRA_HEADERS
+        else:
+            self.model_extra_config["extra_headers"] = DEFAULT_MODEL_EXTRA_HEADERS
+
+        if not self.model:
+            self.model = LiteLlm(
+                model=f"{self.model_provider}/{self.model_name}",
+                api_key=self.model_api_key,
+                api_base=self.model_api_base,
+                **self.model_extra_config,
+            )
+            logger.debug(
+                f"LiteLLM client created with config: {self.model_extra_config}"
+            )
+        else:
+            logger.warning(
+                "You are trying to use your own LiteLLM client, some default request headers may be missing."
+            )
 
         if self.knowledgebase:
             from veadk.tools import load_knowledgebase_tool
@@ -117,7 +137,7 @@ class Agent(LlmAgent):
 
         logger.info(f"{self.__class__.__name__} `{self.name}` init done.")
         logger.debug(
-            f"Agent: {self.model_dump(include={'name', 'model_name', 'model_api_base', 'tools', 'serve_url'})}"
+            f"Agent: {self.model_dump(include={'name', 'model_name', 'model_api_base', 'tools'})}"
         )
 
     async def _run(

{veadk_python-0.2.4 → veadk_python-0.2.5}/veadk/cli/cli_deploy.py

@@ -29,7 +29,9 @@ TEMP_PATH = "/tmp"
     default=None,
     help="Volcengine secret key",
 )
-@click.option("--vefaas-app-name", help="Expected Volcengine FaaS application name")
+@click.option(
+    "--vefaas-app-name", required=True, help="Expected Volcengine FaaS application name"
+)
 @click.option(
     "--veapig-instance-name", default="", help="Expected Volcengine APIG instance name"
 )

{veadk_python-0.2.4 → veadk_python-0.2.5}/veadk/cloud/cloud_app.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import json
+import time
 from typing import Any
 from uuid import uuid4
 
@@ -60,9 +61,11 @@ class CloudApp:
         if not vefaas_endpoint:
             self.vefaas_endpoint = self._get_vefaas_endpoint()
 
-        if not self.vefaas_endpoint.startswith(
-            "http"
-        ) and not self.vefaas_endpoint.startswith("https"):
+        if (
+            self.vefaas_endpoint
+            and not self.vefaas_endpoint.startswith("http")
+            and not self.vefaas_endpoint.startswith("https")
+        ):
             raise ValueError(
                 f"Invalid endpoint: {vefaas_endpoint}. The endpoint must start with `http` or `https`."
             )
@@ -92,12 +95,13 @@ class CloudApp:
             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:
+            cloud_resource = json.loads(app["CloudResource"])
             vefaas_endpoint = cloud_resource["framework"]["url"]["system_url"]
         except Exception as e:
-            raise ValueError(f"VeFaaS cloudAPP could not get endpoint. Error: {e}")
+            logger.warning(f"VeFaaS cloudAPP could not get endpoint. Error: {e}")
+            vefaas_endpoint = ""
         return vefaas_endpoint
 
     def _get_vefaas_application_id_by_name(self) -> str:
@@ -167,7 +171,18 @@ class CloudApp:
 
             vefaas_client = VeFaaS(access_key=volcengine_ak, secret_key=volcengine_sk)
             vefaas_client.delete(self.vefaas_application_id)
-            print(f"Cloud app {self.vefaas_application_id} is deleting...")
+            print(
+                f"Cloud app {self.vefaas_application_id} delete request has been sent to VeFaaS"
+            )
+            while True:
+                try:
+                    id = self._get_vefaas_application_id_by_name()
+                    if not id:
+                        break
+                    time.sleep(3)
+                except Exception as _:
+                    break
+            print("Delete application done.")
 
     async def message_send(
         self, message: str, session_id: str, user_id: str, timeout: float = 600.0

{veadk_python-0.2.4 → veadk_python-0.2.5}/veadk/consts.py

@@ -12,6 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from veadk.version import VERSION
+
 DEFAULT_MODEL_AGENT_NAME = "doubao-seed-1-6-250615"
-DEFALUT_MODEL_AGENT_PROVIDER = "openai"
+DEFAULT_MODEL_AGENT_PROVIDER = "openai"
 DEFAULT_MODEL_AGENT_API_BASE = "https://ark.cn-beijing.volces.com/api/v3/"
+DEFAULT_MODEL_EXTRA_HEADERS = {"veadk-source": "veadk", "veadk-version": VERSION}
+
+DEFAULT_APMPLUS_OTEL_EXPORTER_ENDPOINT = "http://apmplus-cn-beijing.volces.com:4317"
+DEFAULT_APMPLUS_OTEL_EXPORTER_SERVICE_NAME = "veadk_tracing"
+
+DEFAULT_COZELOOP_OTEL_EXPORTER_ENDPOINT = (
+    "https://api.coze.cn/v1/loop/opentelemetry/v1/traces"
+)
+
+DEFAULT_TLS_OTEL_EXPORTER_ENDPOINT = "https://tls-cn-beijing.volces.com:4318/v1/traces"
+DEFAULT_TLS_OTEL_EXPORTER_REGION = "cn-beijing"

{veadk_python-0.2.4 → veadk_python-0.2.5}/veadk/database/viking/viking_database.py

@@ -387,9 +387,9 @@ class VikingDatabase(BaseModel, BaseDatabase):
             logger.error(f"Error in list_collections: {result['message']}")
             raise ValueError(f"Error in list_collections: {result['message']}")
 
-        collections = result["data"]["collection_list"]
-        if not collections:
-            raise ValueError(f"No collections found in project {self.config.project}.")
+        collections = result["data"].get("collection_list", [])
+        if len(collections) == 0:
+            return False
 
         collection_list = set()
 

veadk_python-0.2.5/veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/clean.py

@@ -0,0 +1,23 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from veadk.cloud.cloud_app import CloudApp
+
+def main() -> None:
+    cloud_app = CloudApp(vefaas_application_name="{{cookiecutter.vefaas_application_name}}")
+    cloud_app.delete_self()
+
+
+if __name__ == "__main__":
+    main()

{veadk_python-0.2.4 → veadk_python-0.2.5}/veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/app.py

@@ -26,6 +26,7 @@ from fastmcp import FastMCP
 from starlette.routing import Route
 
 from google.adk.a2a.utils.agent_card_builder import AgentCardBuilder
+from a2a.types import AgentProvider
 
 from veadk.a2a.ve_a2a_server import init_app
 from veadk.runner import Runner
@@ -46,7 +47,9 @@ app_name = agent_run_config.app_name
 agent = agent_run_config.agent
 short_term_memory = agent_run_config.short_term_memory
 
-agent_card_builder = AgentCardBuilder(agent=agent)
+VEFAAS_REGION = os.getenv("APP_REGION", "cn-beijing")
+VEFAAS_FUNC_ID = os.getenv("_FAAS_FUNC_ID", "")
+agent_card_builder = AgentCardBuilder(agent=agent, provider=AgentProvider(organization="Volcengine Agent Development Kit (VeADK)", url=f"https://console.volcengine.com/vefaas/region:vefaas+{VEFAAS_REGION}/function/detail/{VEFAAS_FUNC_ID}"))
 
 
 def load_tracer() -> None:

{veadk_python-0.2.4 → veadk_python-0.2.5}/veadk/integrations/ve_faas/template/{{cookiecutter.local_dir_name}}/src/run.sh

@@ -34,7 +34,17 @@ while [[ $# -gt 0 ]]; do
 done
 
 # in case of deployment deps not installed in user's requirements.txt
-python3 -m pip install uvicorn[standard] fastapi
+if pip list | grep -q "^fastapi \|^uvicorn "; then
+    echo "fastapi and uvicorn already installed"
+else
+    python3 -m pip install uvicorn[standard] fastapi
+fi
+
+# Check if MODEL_AGENT_API_KEY is set
+if [ -z "$MODEL_AGENT_API_KEY" ]; then
+    echo "MODEL_AGENT_API_KEY is not set. Please set it in your environment variables."
+    exit 1
+fi
 
 USE_ADK_WEB=${USE_ADK_WEB:-False}
 

veadk_python-0.2.5/veadk/integrations/ve_tos/ve_tos.py

@@ -0,0 +1,176 @@
+# 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 os
+from veadk.config import getenv
+from veadk.utils.logger import get_logger
+import tos
+import asyncio
+from typing import Union
+from pydantic import BaseModel, Field
+from typing import Any
+from urllib.parse import urlparse
+from datetime import datetime
+
+logger = get_logger(__name__)
+
+
+class TOSConfig(BaseModel):
+    region: str = Field(
+        default_factory=lambda: getenv("DATABASE_TOS_REGION"),
+        description="TOS region",
+    )
+    ak: str = Field(
+        default_factory=lambda: getenv("VOLCENGINE_ACCESS_KEY"),
+        description="Volcengine access key",
+    )
+    sk: str = Field(
+        default_factory=lambda: getenv("VOLCENGINE_SECRET_KEY"),
+        description="Volcengine secret key",
+    )
+    bucket_name: str = Field(
+        default_factory=lambda: getenv("DATABASE_TOS_BUCKET"),
+        description="TOS bucket name",
+    )
+
+
+class VeTOS(BaseModel):
+    config: TOSConfig = Field(default_factory=TOSConfig)
+
+    def model_post_init(self, __context: Any) -> None:
+        try:
+            self._client = tos.TosClientV2(
+                self.config.ak,
+                self.config.sk,
+                endpoint=f"tos-{self.config.region}.volces.com",
+                region=self.config.region,
+            )
+            logger.info("Connected to TOS successfully.")
+        except Exception as e:
+            logger.error(f"Client initialization failed:{e}")
+            return None
+
+    def create_bucket(self) -> bool:
+        """If the bucket does not exist, create it"""
+        try:
+            self._client.head_bucket(self.config.bucket_name)
+            logger.info(f"Bucket {self.config.bucket_name} already exists")
+            return True
+        except tos.exceptions.TosServerError as e:
+            if e.status_code == 404:
+                self._client.create_bucket(
+                    bucket=self.config.bucket_name,
+                    storage_class=tos.StorageClassType.Storage_Class_Standard,
+                    acl=tos.ACLType.ACL_Private,
+                )
+                logger.info(f"Bucket {self.config.bucket_name} created successfully")
+                return True
+        except Exception as e:
+            logger.error(f"Bucket creation failed: {str(e)}")
+            return False
+
+    def build_tos_url(
+        self, user_id: str, app_name: str, session_id: str, data_path: str
+    ) -> tuple[str, str]:
+        """generate TOS object key"""
+        parsed_url = urlparse(data_path)
+
+        if parsed_url.scheme and parsed_url.scheme in ("http", "https", "ftp", "ftps"):
+            file_name = os.path.basename(parsed_url.path)
+        else:
+            file_name = os.path.basename(data_path)
+
+        timestamp: str = datetime.now().strftime("%Y%m%d%H%M%S%f")[:-3]
+        object_key: str = f"{app_name}-{user_id}-{session_id}/{timestamp}-{file_name}"
+        tos_url: str = f"https://{self.config.bucket_name}.tos-{self.config.region}.volces.com/{object_key}"
+
+        return object_key, tos_url
+
+    def upload(
+        self,
+        object_key: str,
+        data: Union[str, bytes],
+    ):
+        if isinstance(data, str):
+            data_type = "file"
+        elif isinstance(data, bytes):
+            data_type = "bytes"
+        else:
+            error_msg = f"Upload failed: data type error. Only str (file path) and bytes are supported, got {type(data)}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        if data_type == "file":
+            return asyncio.to_thread(self._do_upload_file, object_key, data)
+        elif data_type == "bytes":
+            return asyncio.to_thread(self._do_upload_bytes, object_key, data)
+
+    def _do_upload_bytes(self, object_key: str, bytes: bytes) -> bool:
+        try:
+            if not self._client:
+                return False
+            if not self.create_bucket():
+                return False
+            self._client.put_object(
+                bucket=self.config.bucket_name, key=object_key, content=bytes
+            )
+            logger.debug(f"Upload success, object_key: {object_key}")
+            self._close()
+            return True
+        except Exception as e:
+            logger.error(f"Upload failed: {e}")
+            self._close()
+            return False
+
+    def _do_upload_file(self, object_key: str, file_path: str) -> bool:
+        try:
+            if not self._client:
+                return False
+            if not self.create_bucket():
+                return False
+
+            self._client.put_object_from_file(
+                bucket=self.config.bucket_name, key=object_key, file_path=file_path
+            )
+            self._close()
+            logger.debug(f"Upload success, object_key: {object_key}")
+            return True
+        except Exception as e:
+            logger.error(f"Upload failed: {e}")
+            self._close()
+            return False
+
+    def download(self, object_key: str, save_path: str) -> bool:
+        """download image from TOS"""
+        try:
+            object_stream = self._client.get_object(self.config.bucket_name, object_key)
+
+            save_dir = os.path.dirname(save_path)
+            if save_dir and not os.path.exists(save_dir):
+                os.makedirs(save_dir, exist_ok=True)
+
+            with open(save_path, "wb") as f:
+                for chunk in object_stream:
+                    f.write(chunk)
+
+            logger.debug(f"Image download success, saved to: {save_path}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Image download failed: {str(e)}")
+
+            return False
+
+    def _close(self):
+        if self._client:
+            self._client.close()