veadk-python 0.1.0__py3-none-any.whl

veadk/cli/main.py

@@ -0,0 +1,278 @@
+# 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 __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+import sys
+from pathlib import Path
+
+import typer
+import uvicorn
+
+from veadk.utils.logger import get_logger
+from veadk.version import VERSION
+
+logger = get_logger(__name__)
+
+app = typer.Typer(name="vego")
+
+
+@app.command()
+def init():
+    """Init a veadk project that can be deployed to Volcengine VeFaaS."""
+    from rich.prompt import Confirm, Prompt
+
+    cwd = Path.cwd()
+    template_dir = Path(__file__).parent.resolve() / "services" / "vefaas" / "template"
+
+    name = Prompt.ask("Project name", default="veadk-cloud-agent")
+
+    target_dir = cwd / name
+
+    if target_dir.exists():
+        response = Confirm.ask(
+            f"Target directory '{target_dir}' already exists, do you want to overwrite it?: "
+        )
+        if not response:
+            print("Operation cancelled.")
+            return
+        else:
+            shutil.rmtree(target_dir)  # 删除旧目录
+            print(f"Deleted existing directory: {target_dir}")
+
+    shutil.copytree(template_dir, target_dir)
+    print(f"Created new project: {name}")
+
+
+# @app.command()
+# def web(
+#     path: str = typer.Option(".", "--path", help="Agent project path"),
+# ):
+#     from google.adk.cli import cli_tools_click
+
+#     def my_decorator(func):
+#         @wraps(func)
+#         def wrapper(*args, **kwargs):
+#             adk_app: FastAPI = func(*args, **kwargs)
+#             import importlib.util
+#             import mimetypes
+
+#             from fastapi.staticfiles import StaticFiles
+
+#             mimetypes.add_type("application/javascript", ".js", True)
+#             mimetypes.add_type("text/javascript", ".js", True)
+
+#             spec = importlib.util.find_spec("veadk.cli.browser")
+#             if spec is not None:
+#                 ANGULAR_DIST_PATH = spec.submodule_search_locations[0]
+#                 logger.info(f"Static source path: {ANGULAR_DIST_PATH}")
+#             else:
+#                 raise Exception("veadk.cli.browser not found")
+
+#             # ----- 8< Unmount app -----
+#             from starlette.routing import Mount
+
+#             for index, route in enumerate(adk_app.routes):
+#                 if isinstance(route, Mount) and route.path == "/dev-ui":
+#                     del adk_app.routes[index]
+#                     break
+#             # ----- 8< Mount our app -----
+
+#             adk_app.mount(
+#                 "/dev-ui/",
+#                 StaticFiles(directory=ANGULAR_DIST_PATH, html=True),
+#                 name="static",
+#             )
+
+#             from fastapi.middleware.cors import CORSMiddleware
+
+#             adk_app.add_middleware(
+#                 CORSMiddleware,
+#                 allow_origins=["*"],
+#                 allow_credentials=True,
+#                 allow_methods=["*"],
+#                 allow_headers=["*"],
+#             )
+#             return adk_app
+
+#         return wrapper
+
+#     # Monkey patch
+#     fast_api.get_fast_api_app = my_decorator(fast_api.get_fast_api_app)
+
+#     # reload cli_tools_click
+#     importlib.reload(cli_tools_click)
+
+#     agents_dir = str(Path(path).resolve())
+#     logger.info(f"Agents dir is {agents_dir}")
+#     cli_tools_click.cli_web.main(args=[agents_dir])
+
+
+@app.command()
+def web(
+    session_service_uri: str = typer.Option(
+        None,
+        "--session_service_uri",
+    ),
+):
+    from google.adk.memory import in_memory_memory_service
+
+    from veadk.memory.long_term_memory import LongTermMemory
+
+    in_memory_memory_service.InMemoryMemoryService = LongTermMemory
+
+    from google.adk.cli import cli_tools_click
+
+    importlib.reload(cli_tools_click)
+    agents_dir = os.getcwd()
+    if not session_service_uri:
+        session_service_uri = ""
+
+    cli_tools_click.cli_web.main(
+        args=[agents_dir, "--session_service_uri", session_service_uri]
+    )
+
+
+@app.command()
+def studio(
+    path: str = typer.Option(".", "--path", help="Project path"),
+):
+    path = Path(path).resolve()
+
+    from veadk.cli.studio.fast_api import get_fast_api_app
+
+    app = get_fast_api_app(agents_dir=str(path))
+
+    uvicorn.run(
+        app,
+        host="127.0.0.1",
+        port=8000,
+        log_level="info",
+        loop="asyncio",  # for deepeval
+    )
+
+
+@app.command()
+def prompt(
+    path: str = typer.Option(
+        ...,
+        "--path",
+        help="Your agent file path. Please ensure that your agent(s) are global variable(s).",
+    ),
+    feedback: str = typer.Option(
+        "",
+        "--feedback",
+        help="Feedback of prompt from agent evaluation.",
+    ),
+    api_key: str = typer.Option(
+        ..., "--api-key", help="API Key of AgentPilot Platform"
+    ),
+    model_name: str = typer.Option(
+        "doubao-1.5-pro-32k-250115",
+        "--model-name",
+        help="Model name for prompt optimization",
+    ),
+):
+    from veadk import Agent
+
+    """
+    NOTE(nkfyz): Detecting agents from a file is not fully correct, we will fix this feature asap.
+    """
+    module_name = "veadk_agent"
+    path = Path(path).resolve()
+    logger.info(f"Detect agents in {path}")
+
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    globals_in_module = vars(module)  # get all global variables in module
+
+    agents = []
+    for global_variable_name, global_variable_value in globals_in_module.items():
+        if isinstance(global_variable_value, Agent):
+            agent = global_variable_value
+            agents.append(agent)
+    logger.info(f"Found {len(agents)} agent(s) in {path}")
+
+    if len(agents) == 0:
+        logger.info(
+            "No agent found. Please put your agent definition as a global variable in your agent file."
+        )
+        print(
+            f"No agent found in {path}. Please put your agent definition as a global variable in your agent file."
+        )
+        return
+
+    from veadk.cli.services.agentpilot import AgentPilot
+
+    ap = AgentPilot(api_key)
+    ap.optimize(agents=agents, feedback=feedback, model_name=model_name)
+
+
+# @app.command()
+# def studio():
+#     import os
+
+#     # pre-load
+#     from veadk import Agent  # noqa
+
+#     os.environ["VEADK_STUDIO_AGENTS_DIR"] = os.getcwd()
+#     app_path = os.path.join(os.path.dirname(__file__), "../../app/app.py")
+
+#     os.system(f"streamlit run {app_path}")
+
+
+@app.command()
+def deploy(
+    access_key: str = typer.Option(..., "--access-key", help="Access Key"),
+    secret_key: str = typer.Option(..., "--secret-key", help="Secret Key"),
+    name: str = typer.Option(..., "--name", help="Deployment name"),
+    path: str = typer.Option(".", "--path", help="Project path"),
+):
+    from veadk.cli.services.vefaas import VeFaaS
+
+    path = Path(path).resolve()
+    vefaas = VeFaaS(access_key, secret_key)
+    vefaas.deploy(name=name, path=path)
+
+
+@app.command()
+def log(
+    access_key: str = typer.Option(..., "--access-key", help="Access Key"),
+    secret_key: str = typer.Option(..., "--secret-key", help="Secret Key"),
+    query: str = typer.Option(..., "--query", help="Query statement"),
+    topic_id: str = typer.Option(..., "--topic-id", help="Topic ID in VeTLS"),
+    dump_path: str = typer.Option(
+        ".", "--dump-path", help="Local path for log storage file"
+    ),
+):
+    path = Path(dump_path).resolve()
+
+    from veadk.cli.services.vetls import VeTLS
+
+    vetls = VeTLS(access_key, secret_key, dump_path=str(path))
+    vetls.query(topic_id=topic_id, query=query)
+
+
+@app.command()
+def version():
+    print(f"VeADK {VERSION}")
+
+
+if __name__ == "__main__":
+    app()

veadk/cli/services/agentpilot/__init__.py

@@ -0,0 +1,17 @@
+# 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 .agentpilot import AgentPilot
+
+__all__ = ["AgentPilot"]

veadk/cli/services/agentpilot/agentpilot.py

@@ -0,0 +1,77 @@
+# 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 __future__ import annotations
+
+import agent_pilot as ap
+from agent_pilot.models import TaskType
+
+from veadk import Agent
+from veadk.prompts import prompt_optimization
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class AgentPilot:
+    def __init__(self, api_key: str, path: str = "", task_id: str = None) -> None:
+        self.api_key = api_key
+        self.path = path
+        self.task_id = task_id
+
+    def optimize(
+        self,
+        agents: list[Agent],
+        feedback: str = "",
+        model_name: str = "doubao-1.5-pro-32k-250115",
+    ) -> str:
+        for idx, agent in enumerate(agents):
+            optimized_prompt = ""
+            if feedback == "":
+                logger.info("Optimizing prompt without feedback.")
+                task_description = prompt_optimization.render_prompt_with_jinja2(agent)
+            else:
+                logger.info(f"Optimizing prompt with feedback: {feedback}")
+                task_description = (
+                    prompt_optimization.render_prompt_feedback_with_jinja2(
+                        agent, feedback
+                    )
+                )
+
+            logger.info(
+                f"Optimizing prompt for agent {agent.name} by {model_name} [{idx + 1}/{len(agents)}]"
+            )
+
+            usage = None
+            for chunk in ap.generate_prompt_stream(
+                task_description=task_description,
+                current_prompt=agent.instruction,
+                model_name=model_name,
+                task_type=TaskType.DIALOG,
+                temperature=1.0,
+                top_p=0.7,
+                api_key=self.api_key,
+            ):  # stream chunks of optimized prompt
+                # Process each chunk as it arrives
+                optimized_prompt += chunk.data.content
+                # print(chunk.data.content, end="", flush=True)
+                if chunk.event == "usage":
+                    usage = chunk.data.usage
+            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']}")
+
+        return optimized_prompt
+        return optimized_prompt
+        return optimized_prompt

veadk/cli/services/veapig/__init__.py

@@ -0,0 +1,17 @@
+# 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 .apig import APIGateway
+
+__all__ = ["APIGateway"]

veadk/cli/services/veapig/apig.py

@@ -0,0 +1,224 @@
+# 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 time
+
+import volcenginesdkcore
+from volcenginesdkapig import (
+    APIGApi,
+    ListGatewaysRequest,
+    UpstreamSpecForCreateUpstreamInput,
+    VeFaasForCreateUpstreamInput,
+)
+from volcenginesdkapig20221112 import APIG20221112Api, UpstreamListForCreateRouteInput
+
+
+class APIGateway:
+    def __init__(self, access_key: str, secret_key: str, region: str = "cn-beijing"):
+        self.ak = access_key
+        self.sk = secret_key
+        self.region = region
+        configuration = volcenginesdkcore.Configuration()
+        configuration.ak = self.ak
+        configuration.sk = self.sk
+        configuration.region = region
+
+        self.api_client = volcenginesdkcore.ApiClient(configuration=configuration)
+        self.apig_20221112_client = APIG20221112Api(api_client=self.api_client)
+        self.apig_client = APIGApi(api_client=self.api_client)
+
+    def list_gateways(self):
+        request = ListGatewaysRequest()
+        thread = self.apig_client.list_gateways(request, async_req=True)
+        result = thread.get()
+        return result
+
+    def create_serverless_gateway(self, instance_name: str) -> str:  # instance
+        from volcenginesdkapig import (
+            CreateGatewayRequest,
+            ResourceSpecForCreateGatewayInput,
+        )
+
+        request = CreateGatewayRequest(
+            name=instance_name,
+            region=self.region,
+            type="serverless",
+            resource_spec=ResourceSpecForCreateGatewayInput(
+                replicas=2,
+                instance_spec_code="1c2g",
+                clb_spec_code="small_1",
+                public_network_billing_type="traffic",
+                network_type={
+                    "EnablePublicNetwork": True,
+                    "EnablePrivateNetwork": False,
+                },
+            ),
+        )
+        thread = self.apig_client.create_gateway(request, async_req=True)
+        result = thread.get()
+        gateway_id = result.to_dict()["id"]
+
+        found = False
+        while not found:
+            request = ListGatewaysRequest()
+            thread = self.apig_client.list_gateways(request, async_req=True)
+            result = thread.get()
+            for item in result.items:
+                if (
+                    item.to_dict()["id"] == gateway_id
+                    and item.to_dict()["status"] == "Running"
+                ):
+                    found = True
+                    break
+            if not found:
+                time.sleep(5)
+        return gateway_id
+
+    def create_gateway_service(self, gateway_id: str, service_name: str) -> str:
+        """
+        Create a gateway service. (Domain name)
+        Args:
+            gateway_id (str): The ID of the gateway to which the service belongs.
+            service_name (str): The name of the service to be created.
+        Returns:
+            str: The ID of the created service.
+        """
+        from volcenginesdkapig import (
+            AuthSpecForCreateGatewayServiceInput,
+            CreateGatewayServiceRequest,
+        )
+
+        request = CreateGatewayServiceRequest(
+            gateway_id=gateway_id,
+            service_name=service_name,
+            protocol=["HTTP", "HTTPS"],
+            auth_spec=AuthSpecForCreateGatewayServiceInput(enable=False),
+        )
+        thread = self.apig_client.create_gateway_service(request, async_req=True)
+        result = thread.get()
+        return result.to_dict()["id"]
+
+    def create_upstream(self, function_id: str, gateway_id: str, upstream_name: str):
+        from volcenginesdkapig import CreateUpstreamRequest
+
+        request = CreateUpstreamRequest(
+            gateway_id=gateway_id,
+            name=upstream_name,
+            source_type="VeFaas",
+            upstream_spec=UpstreamSpecForCreateUpstreamInput(
+                ve_faas=VeFaasForCreateUpstreamInput(function_id=function_id)
+            ),
+        )
+        thread = self.apig_client.create_upstream(request, async_req=True)
+        result = thread.get()
+        return result.to_dict()["id"]
+
+    def create_gateway_service_routes(
+        self, service_id: str, upstream_id: str, route_name: str, match_rule: dict
+    ):
+        """
+        Create gateway service routes.
+
+        Args:
+            service_id (str): The ID of the gateway service, used to specify the target service for which the route is to be created.
+            upstream_id (str): The ID of the upstream service, to which the route will point.
+            route_name (str): The name of the route to be created.
+            match_rule (dict): The route matching rule, containing the following key - value pairs:
+                - match_content (str): The path matching content, a string like "/abc", used to specify the path to be matched.
+                - match_type (str): The path matching type, with optional values "Exact", "Regex", "Prefix".
+                - match_method (list[str]): The list of HTTP request methods, possible values include "GET", "POST", etc.
+        Returns:
+            str: The ID of the created route.
+        """
+        from volcenginesdkapig20221112 import (
+            CreateRouteRequest,
+            MatchRuleForCreateRouteInput,
+            PathForCreateRouteInput,
+        )
+
+        match_content: str = match_rule["match_content"]
+        match_type: str = match_rule["match_type"]
+        match_method: list[str] = match_rule["match_method"]
+
+        request = CreateRouteRequest(
+            service_id=service_id,
+            enable=True,
+            match_rule=MatchRuleForCreateRouteInput(
+                path=PathForCreateRouteInput(
+                    match_content=match_content, match_type=match_type
+                ),
+                method=match_method,
+            ),
+            name=route_name,
+            priority=1,
+            upstream_list=[
+                UpstreamListForCreateRouteInput(
+                    upstream_id=upstream_id,
+                    weight=1,
+                )
+            ],
+        )
+
+        thread = self.apig_20221112_client.create_route(request, async_req=True)
+        result = thread.get()
+        return result.to_dict()["id"]
+
+    def create(
+        self,
+        function_id: str,
+        apig_instance_name: str,
+        service_name: str,
+        upstream_name: str,
+        routes: list[dict],
+    ):
+        """
+        Create an API gateway instance, service, and multiple routes.
+
+        Args:
+            function_id (str): The ID of the function to be associated with the routes.
+            apig_instance_name (str): The name of the API gateway instance.
+            service_name (str): The name of the service to be created.
+            upstream_name (str): The name of the upstream service to be created.
+            routes (list[dict]): A list of route configurations. Each dictionary in the list contains the following key - value pairs:
+                - route_name (str): The name of the route to be created.
+                - match_content (str): The path matching content, a string like "/abc", used to specify the path to be matched.
+                - match_type (str): The path matching type, with optional values "Exact", "Regex", "Prefix".
+                - match_method (list[str]): The list of HTTP request methods, possible values include "GET", "POST", etc.
+
+        Returns:
+            dict: A dictionary containing the IDs of the created gateway, service, upstream, and routes.
+        """
+        gateway_id = self.create_serverless_gateway(apig_instance_name)
+        service_id = self.create_gateway_service(gateway_id, service_name)
+        upstream_id = self.create_upstream(function_id, gateway_id, upstream_name)
+
+        route_ids = []
+        for route in routes:
+            route_name = route["route_name"]
+            match_rule = {
+                "match_content": route["match_content"],
+                "match_type": route["match_type"],
+                "match_method": route["match_method"],
+            }
+            route_id = self.create_gateway_service_routes(
+                service_id, upstream_id, route_name, match_rule
+            )
+            route_ids.append(route_id)
+
+        return {
+            "gateway_id": gateway_id,
+            "service_id": service_id,
+            "upstream_id": upstream_id,
+            "route_ids": route_ids,
+        }