veadk-python 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

veadk/integrations/ve_faas/ve_faas.py

@@ -13,10 +13,10 @@
 # limitations under the License.
 
 import json
+import os
 import time
 
 import requests
-import typer
 import volcenginesdkcore
 import volcenginesdkvefaas
 from volcenginesdkvefaas.models.env_for_create_function_input import (
@@ -118,6 +118,7 @@ class VeFaaS:
                 runtime="native-python3.10/v1",
                 request_timeout=1800,
                 envs=envs,
+                memory_mb=2048,
             )
         )
 
@@ -141,6 +142,8 @@ class VeFaaS:
         upstream_name: str,
         service_name: str,
     ):
+        enable_key_auth = os.getenv("VEFAAS_ENABLE_KEY_AUTH", "true").lower() == "true"
+
         response = ve_request(
             request_body={
                 "Name": application_name,
@@ -152,7 +155,7 @@ class VeFaaS:
                     "GatewayName": gateway_name,
                     "ServiceName": service_name,
                     "UpstreamName": upstream_name,
-                    "EnableKeyAuth": True,
+                    "EnableKeyAuth": enable_key_auth,
                     "EnableMcpSession": True,
                 },
                 "TemplateId": self.template_id,
@@ -191,16 +194,27 @@ class VeFaaS:
             time.sleep(10)
             status, full_response = self._get_application_status(app_id)
 
-        assert status == "deploy_success", (
-            f"Release application failed. Response: {full_response}"
-        )
-
-        cloud_resource = full_response["Result"]["CloudResource"]
-        cloud_resource = json.loads(cloud_resource)
-
-        url = cloud_resource["framework"]["url"]["system_url"]
-
-        return url
+        if status == "deploy_success":
+            cloud_resource = full_response["Result"]["CloudResource"]
+            cloud_resource = json.loads(cloud_resource)
+            url = cloud_resource["framework"]["url"]["system_url"]
+            return url
+        else:
+            logger.error(
+                f"Release application failed. Application ID: {app_id}, Status: {status}"
+            )
+            import re
+
+            logs = "\n".join(self._get_application_logs(app_id=app_id))
+            log_text = re.sub(
+                r'([{"\']?(key|secret|token|pass|auth|credential|access|api|ak|sk|doubao|volces|coze)[^"\'\s]*["\']?\s*[:=]\s*)(["\']?)([^"\'\s]+)(["\']?)|([A-Za-z0-9+/=]{20,})',
+                lambda m: f"{m.group(1)}{m.group(3)}******{m.group(5)}"
+                if m.group(1)
+                else "******",
+                logs,
+                flags=re.IGNORECASE,
+            )
+            raise Exception(f"Release application failed. Logs:\n{log_text}")
 
     def _get_application_status(self, app_id: str):
         response = ve_request(
@@ -215,18 +229,51 @@ class VeFaaS:
         )
         return response["Result"]["Status"], response
 
-    def _list_application(self):
-        response = ve_request(
-            request_body={},
-            action="ListApplications",
-            ak=self.ak,
-            sk=self.sk,
-            service="vefaas",
-            version="2021-03-03",
-            region="cn-beijing",
-            host="open.volcengineapi.com",
-        )
-        return response["Result"]["Items"]
+    def _list_application(self, app_id: str = None, app_name: str = None):
+        # firt match app_id. if app_id is None,then match app_name and remove app_id
+        request_body = {
+            "OrderBy": {"Key": "CreateTime", "Ascend": False},
+            "FunctionId": app_id if app_id else None,
+            "Filters": [{"Item": {"Key": "Name", "Value": [app_name]}}]
+            if app_name and not app_id
+            else None,
+        }
+        # remove None
+        request_body = {k: v for k, v in request_body.items() if v is not None}
+
+        page_size = 50
+        page_number = 1
+        all_items = []
+        total_page = None
+        while True:
+            try:
+                request_body.update({"PageNumber": page_number, "PageSize": page_size})
+                response = ve_request(
+                    request_body=request_body,
+                    action="ListApplications",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+                result = response.get("Result", {})
+                items = result.get("Items", [])
+                all_items.extend(items)
+
+                if total_page is None:
+                    total = result.get("Total", 0)
+                    total_page = (total + page_size - 1) // page_size
+
+                if page_number >= total_page or not items:
+                    break
+                page_number += 1
+            except Exception as e:
+                raise ValueError(
+                    f"List application failed. Error: {str(e)}. Response: {response}."
+                )
+        return all_items
 
     def _update_function_code(
         self,
@@ -255,10 +302,6 @@ class VeFaaS:
 
         # Get application status and extract function info
         status, full_response = self._get_application_status(app_id)
-        if status == "deploy_fail":
-            raise ValueError(
-                f"Cannot update failed application. Current status: {status}"
-            )
 
         # Extract function name from application config
         cloud_resource = full_response["Result"]["CloudResource"]
@@ -302,7 +345,7 @@ class VeFaaS:
     def get_application_details(self, app_id: str = None, app_name: str = None):
         if not app_id and not app_name:
             raise ValueError("app_id and app_name cannot be both empty.")
-        apps = self._list_application()
+        apps = self._list_application(app_id=app_id, app_name=app_name)
         if app_id:
             for app in apps:
                 if app["Id"] == app_id:
@@ -314,7 +357,7 @@ class VeFaaS:
                     return app
 
     def find_app_id_by_name(self, name: str):
-        apps = self._list_application()
+        apps = self._list_application(app_name=name)
         for app in apps:
             if app["Name"] == name:
                 return app["Id"]
@@ -334,12 +377,7 @@ class VeFaaS:
                 host="open.volcengineapi.com",
             )
         except Exception as e:
-            typer.echo(
-                typer.style(
-                    f"Delete application failed. Response: {e}",
-                    fg=typer.colors.BRIGHT_RED,
-                )
-            )
+            logger.error(f"Delete application failed. Response: {e}")
 
     def deploy(
         self,
@@ -411,3 +449,280 @@ class VeFaaS:
         logger.info(f"VeFaaS application {name} with ID {app_id} deployed on {url}.")
 
         return url, app_id, function_id
+
+    def _create_image_function(self, function_name: str, image: str):
+        """Create function using container image instead of code upload."""
+        # Read environment variables from veadk configuration
+        envs = []
+        for key, value in veadk.config.veadk_environments.items():
+            envs.append(EnvForCreateFunctionInput(key=key, value=value))
+        logger.info(
+            f"Fetch {len(envs)} environment variables for image function.",
+        )
+
+        # Create function with container image source configuration
+        res = self.client.create_function(
+            volcenginesdkvefaas.CreateFunctionRequest(
+                command="bash ./run.sh",  # Custom startup command
+                name=function_name,
+                description="Created by VeADK (Volcengine Agent Development Kit)",
+                tags=[TagForCreateFunctionInput(key="provider", value="veadk")],
+                runtime="native/v1",  # Native runtime required for container images
+                source_type="image",  # Set source type to container image
+                source=image,  # Container image URL
+                request_timeout=1800,  # Request timeout in seconds
+                envs=envs,  # Environment variables from configuration
+            )
+        )
+
+        # Log function creation success without exposing sensitive information
+        logger.debug(
+            f"Function creation in {res.project_name} project with ID {res.id}"
+        )
+
+        function_id = res.id
+        logger.info(
+            f"Function {function_name} created with image {image} and ID {function_id}"
+        )
+
+        return function_name, function_id
+
+    def query_user_cr_vpc_tunnel(
+        self, registry_name: str, max_attempts: int = 6
+    ) -> bool:
+        """Query and enable CR VPC tunnel for user registry access."""
+        logger.info(f"Setting up CR VPC tunnel for registry: {registry_name}")
+        waiting_times = 30
+
+        try:
+            for attempt in range(max_attempts):
+                # Check current status
+                logger.info(
+                    f"Checking tunnel status (attempt {attempt + 1}/{max_attempts})"
+                )
+                query_resp = ve_request(
+                    request_body={"Registry": registry_name},
+                    action="QueryUserCrVpcTunnel",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+
+                current_status = query_resp.get("Result", {}).get("Ready", False)
+                logger.info(f"Current tunnel status: {current_status}")
+
+                # Always try to enable
+                logger.info("Enable VPC tunnel")
+                enable_resp = ve_request(
+                    request_body={"Registry": registry_name},
+                    action="EnableUserCrVpcTunnel",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+
+                # Handle EnableUserCrVpcTunnel response correctly
+                enable_result = enable_resp.get("Result", {})
+                enable_status = enable_result.get("Status", "")
+                enable_message = enable_result.get("Message", "")
+
+                if enable_status == "success":
+                    logger.info("Enable tunnel succeeded")
+                elif enable_status == "failed":
+                    logger.warning(f"Enable tunnel failed: {enable_message}")
+                else:
+                    logger.warning(f"Enable tunnel unknown status: {enable_status}")
+
+                # Verify final status
+                logger.info("Verifying tunnel status")
+                verify_resp = ve_request(
+                    request_body={"Registry": registry_name},
+                    action="QueryUserCrVpcTunnel",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+
+                final_status = verify_resp.get("Result", {}).get("Ready", False)
+                logger.info(f"Final tunnel status: {final_status}")
+
+                if final_status:
+                    logger.info(
+                        f"CR VPC tunnel successfully enabled for {registry_name}"
+                    )
+                    return True
+
+                # If not ready and not last attempt, wait and retry
+                if attempt < max_attempts - 1:
+                    logger.warning(
+                        f"Tunnel not ready, waiting {waiting_times}s before retry"
+                    )
+                    time.sleep(waiting_times)
+
+        except Exception as e:
+            raise ValueError(f"Failed to setup CR VPC tunnel: {str(e)}")
+
+        return False
+
+    def _create_image_function(self, function_name: str, image: str):
+        """Create function using container image instead of code upload."""
+        # Read environment variables from veadk configuration
+        envs = []
+        for key, value in veadk.config.veadk_environments.items():
+            envs.append(EnvForCreateFunctionInput(key=key, value=value))
+        logger.info(
+            f"Fetch {len(envs)} environment variables for image function.",
+        )
+
+        # Create function with container image source configuration
+        res = self.client.create_function(
+            volcenginesdkvefaas.CreateFunctionRequest(
+                command="bash ./run.sh",  # Custom startup command
+                name=function_name,
+                description="Created by VeADK (Volcengine Agent Development Kit)",
+                tags=[TagForCreateFunctionInput(key="provider", value="veadk")],
+                runtime="native/v1",  # Native runtime required for container images
+                source_type="image",  # Set source type to container image
+                source=image,  # Container image URL
+                request_timeout=1800,  # Request timeout in seconds
+                envs=envs,  # Environment variables from configuration
+            )
+        )
+
+        # Log function creation success without exposing sensitive information
+        logger.debug(
+            f"Function creation in {res.project_name} project with ID {res.id}"
+        )
+
+        function_id = res.id
+        logger.info(
+            f"Function {function_name} created with image {image} and ID {function_id}"
+        )
+
+        return function_name, function_id
+
+    def deploy_image(
+        self,
+        name: str,
+        image: str,
+        registry_name: str,
+        gateway_name: str = "",
+        gateway_service_name: str = "",
+        gateway_upstream_name: str = "",
+    ) -> tuple[str, str, str]:
+        """Deploy application using container image.
+
+        Args:
+            name (str): Application name.
+            image (str): Container image URL.
+            gateway_name (str, optional): Gateway name. Defaults to "".
+            gateway_service_name (str, optional): Gateway service name. Defaults to "".
+            gateway_upstream_name (str, optional): Gateway upstream name. Defaults to "".
+
+        Returns:
+            tuple[str, str, str]: (url, app_id, function_id)
+        """
+        # Validate application name format
+        is_ready = self.query_user_cr_vpc_tunnel(registry_name)
+        if not is_ready:
+            raise ValueError("CR VPC tunnel is not ready")
+
+        if "_" in name:
+            raise ValueError("Function or Application name cannot contain '_'.")
+
+        # Generate default gateway names with timestamp if not provided
+        if not gateway_name:
+            gateway_name = f"{name}-gw-{formatted_timestamp()}"
+
+            # Check for existing serverless gateways to reuse
+            existing_gateways = self.apig_client.list_gateways()
+            for gateway_instance in existing_gateways.items:
+                if (
+                    gateway_instance.type == "serverless"
+                    and gateway_instance.name != gateway_name
+                ):
+                    logger.warning(
+                        f"You have at least one serverless gateway {gateway_instance.name}, but not {gateway_name}. Using {gateway_instance.name} instead."
+                    )
+                    gateway_name = gateway_instance.name
+                    break
+
+        # Set default gateway service and upstream names
+        if not gateway_service_name:
+            gateway_service_name = f"{name}-gw-svr-{formatted_timestamp()}"
+        if not gateway_upstream_name:
+            gateway_upstream_name = f"{name}-gw-us-{formatted_timestamp()}"
+
+        function_name = f"{name}-fn"
+
+        # Log deployment start with image information
+        logger.info(
+            f"Start to create VeFaaS function {function_name} with image {image}. Gateway: {gateway_name}, Gateway Service: {gateway_service_name}, Gateway Upstream: {gateway_upstream_name}."
+        )
+
+        # Create function using container image method
+        function_name, function_id = self._create_image_function(function_name, image)
+        logger.info(f"VeFaaS function {function_name} with ID {function_id} created.")
+
+        # Create application using existing application creation logic
+        logger.info(f"Start to create VeFaaS application {name}.")
+        app_id = self._create_application(
+            name,
+            function_name,
+            gateway_name,
+            gateway_upstream_name,
+            gateway_service_name,
+        )
+
+        # Release application and get deployment URL
+        logger.info(f"VeFaaS application {name} with ID {app_id} created.")
+        logger.info(f"Start to release VeFaaS application {app_id}.")
+        # Release application with retry
+        max_attempts = 5
+        attempt = 0
+        while True:
+            try:
+                url = self._release_application(app_id)
+                logger.info(f"VeFaaS application {name} with ID {app_id} released.")
+                break
+            except Exception:
+                attempt += 1
+                if attempt < max_attempts:
+                    wait_time = 30 * attempt
+                    logger.info(
+                        f"Image sync still in progress. Waiting {wait_time} seconds before retry {attempt}/{max_attempts}."
+                    )
+                    time.sleep(wait_time)
+                else:
+                    raise
+
+        logger.info(f"VeFaaS application {name} with ID {app_id} deployed on {url}.")
+
+        return url, app_id, function_id
+
+    def _get_application_logs(self, app_id: str) -> list[str]:
+        response = _ = ve_request(
+            request_body={"Id": app_id, "Limit": 99999, "RevisionNumber": 1},
+            action="GetApplicationRevisionLog",
+            ak=self.ak,
+            sk=self.sk,
+            service="vefaas",
+            version="2021-03-03",
+            region="cn-beijing",
+            host="open.volcengineapi.com",
+        )
+
+        try:
+            logs = response["Result"]["LogLines"]
+            return logs
+        except Exception as _:
+            raise ValueError(f"Get application log failed. Response: {response}")

veadk/integrations/ve_prompt_pilot/ve_prompt_pilot.py

@@ -65,12 +65,15 @@ class VePromptPilot:
                 api_key=self.api_key,
             ):  # stream chunks of optimized prompt
                 # Process each chunk as it arrives
-                optimized_prompt += chunk.data.content
+                optimized_prompt += chunk.data.content if chunk.data else ""
                 # print(chunk.data.content, end="", flush=True)
                 if chunk.event == "usage":
-                    usage = chunk.data.usage
+                    usage = chunk.data.usage if chunk.data else 0
             optimized_prompt = optimized_prompt.replace("\\n", "\n")
             print(f"Optimized prompt for agent {agent.name}:\n{optimized_prompt}")
-            logger.info(f"Token usage: {usage['total_tokens']}")
+            if usage:
+                logger.info(f"Token usage: {usage['total_tokens']}")
+            else:
+                logger.warning("No usage data.")
 
         return optimized_prompt

veadk/integrations/ve_tls/__init__.py

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

veadk/integrations/ve_tls/utils.py

@@ -0,0 +1,117 @@
+# 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 hashlib
+import json
+from typing import Any, Literal
+
+import httpx
+from volcengine.ApiInfo import ApiInfo
+from volcengine.auth.SignerV4 import SignerV4
+from volcengine.tls.const import (
+    APPLICATION_JSON,
+    CONTENT_MD5,
+    CONTENT_TYPE,
+    DATA,
+    WEB_TRACKS,
+)
+from volcengine.tls.TLSService import TLSService
+
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+HEADER_API_VERSION = "x-tls-apiversion"
+API_VERSION_V_0_3_0 = "0.3.0"
+
+API_INFO = {
+    "CreateProject": ApiInfo("POST", "/CreateProject", {}, {}, {}),
+    "DescribeProjects": ApiInfo("GET", "/DescribeProjects", {}, {}, {}),
+    "CreateTraceInstance": ApiInfo("POST", "/CreateTraceInstance", {}, {}, {}),
+    "DescribeTraceInstances": ApiInfo("GET", "/DescribeTraceInstances", {}, {}, {}),
+    "DescribeTraceInstance": ApiInfo("GET", "/DescribeTraceInstance", {}, {}, {}),
+}
+
+
+def __prepare_request(
+    client: TLSService,
+    api: str,
+    params: dict | None = None,
+    body: Any | None = None,
+    request_headers: dict | None = None,
+):
+    if params is None:
+        params = {}
+    if body is None:
+        body = {}
+
+    request = client.prepare_request(API_INFO[api], params)
+
+    if request_headers is None:
+        request_headers = {CONTENT_TYPE: APPLICATION_JSON}
+    request.headers.update(request_headers)
+
+    if "json" in request.headers[CONTENT_TYPE] and api != WEB_TRACKS:
+        request.body = json.dumps(body)
+    else:
+        request.body = body[DATA]
+
+    if len(request.body) != 0:
+        if isinstance(request.body, str):
+            request.headers[CONTENT_MD5] = hashlib.md5(
+                request.body.encode("utf-8")
+            ).hexdigest()
+        else:
+            request.headers[CONTENT_MD5] = hashlib.md5(request.body).hexdigest()
+
+    SignerV4.sign(request, client.service_info.credentials)
+
+    return request
+
+
+def ve_tls_request(
+    client: TLSService,
+    api: str,
+    params: dict | None = None,
+    body: dict | None = None,
+    request_headers: dict | None = None,
+    method: Literal["POST", "GET", "PUT", "DELETE"] = "POST",
+):
+    """Customize a standard HTTP request to the Volcengine TLS API"""
+
+    if request_headers is None:
+        request_headers = {HEADER_API_VERSION: API_VERSION_V_0_3_0}
+    elif HEADER_API_VERSION not in request_headers:
+        request_headers[HEADER_API_VERSION] = API_VERSION_V_0_3_0
+    if CONTENT_TYPE not in request_headers:
+        request_headers[CONTENT_TYPE] = APPLICATION_JSON
+    request = __prepare_request(client, api, params, body, request_headers)
+
+    url = request.build()
+
+    with httpx.Client() as session:
+        while True:
+            try:
+                response = session.request(
+                    method=method,
+                    url=url,
+                    headers=request.headers,
+                    data=request.body,  # type: ignore
+                    timeout=60,
+                )
+                return response.json()
+            except Exception as e:
+                logger.error(
+                    f"Error occurred while making {method} request to {url}: {e}. Response: {response}"
+                )