veadk-python 0.5.33__tar.gz → 0.5.35__tar.gz

{veadk_python-0.5.33 → veadk_python-0.5.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veadk-python
-Version: 0.5.33
+Version: 0.5.35
 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
@@ -211,7 +211,7 @@ License-File: LICENSE
 Requires-Dist: pydantic-settings==2.10.1
 Requires-Dist: a2a-sdk==0.3.7
 Requires-Dist: deprecated==1.2.18
-Requires-Dist: google-adk==1.19.0
+Requires-Dist: google-adk==1.32.0
 Requires-Dist: litellm<=1.82.6,>=1.74.3
 Requires-Dist: loguru==0.7.3
 Requires-Dist: opentelemetry-exporter-otlp==1.37.0
@@ -222,7 +222,7 @@ Requires-Dist: volcengine>=1.0.193
 Requires-Dist: agent-pilot-sdk==0.1.2
 Requires-Dist: fastmcp>=2.12.3
 Requires-Dist: trustedmcp==0.0.5
-Requires-Dist: mcp==1.23.0
+Requires-Dist: mcp==1.26.0
 Requires-Dist: cookiecutter==2.6.0
 Requires-Dist: omegaconf==2.3.0
 Requires-Dist: psycopg2-binary==2.9.10

{veadk_python-0.5.33 → veadk_python-0.5.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "veadk-python"
-version = "0.5.33"
+version = "0.5.35"
 description = "Volcengine agent development kit, integrations with Volcengine cloud services."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -15,7 +15,7 @@ dependencies = [
     "pydantic-settings==2.10.1", # Config management
     "a2a-sdk==0.3.7", # For Google Agent2Agent protocol
     "deprecated==1.2.18",
-    "google-adk==1.19.0", # For basic agent architecture
+    "google-adk==1.32.0", # For basic agent architecture
     "litellm>=1.74.3,<=1.82.6", # For model inference
     "loguru==0.7.3", # For better logging
     "opentelemetry-exporter-otlp==1.37.0",
@@ -26,7 +26,7 @@ dependencies = [
     "agent-pilot-sdk==0.1.2", # Prompt optimization by Volcengine AgentPilot/PromptPilot toolkits
     "fastmcp>=2.12.3", # For running MCP
     "trustedmcp==0.0.5", # For running TrustedMCP
-    "mcp==1.23.0", # There might be some async generator problem logs in mcp 1.25.0
+    "mcp==1.26.0", # Bumped to satisfy google-adk 1.32.0 requirement
     "cookiecutter==2.6.0", # For cloud deploy
     "omegaconf==2.3.0", # For agent builder
     "psycopg2-binary==2.9.10", # For PostgreSQL database (short term memory)

{veadk_python-0.5.33 → veadk_python-0.5.35}/tests/test_feishu_channel_extension.py

@@ -19,6 +19,11 @@ import pytest
 from veadk.extensions.feishu_channel import FeishuChannelExtension
 
 
+@pytest.fixture
+def anyio_backend():
+    return "asyncio"
+
+
 class FakeChannel:
     def __init__(self):
         self.handlers = {}
@@ -31,6 +36,25 @@ class FakeChannel:
         self.sent_messages.append((chat_id, body, options))
 
 
+class FakeStreamController:
+    def __init__(self):
+        self.chunks = []
+
+    async def append(self, chunk):
+        self.chunks.append(chunk)
+
+
+class FakeStreamChannel(FakeChannel):
+    def __init__(self):
+        super().__init__()
+        self.stream_calls = []
+
+    async def stream(self, chat_id, spec, options=None):
+        controller = FakeStreamController()
+        await spec["markdown"](controller)
+        self.stream_calls.append((chat_id, controller.chunks, options))
+
+
 class FakeRunner:
     def __init__(self):
         self.calls = []
@@ -46,6 +70,46 @@ class FakeRunner:
         return f"echo:{messages}"
 
 
+class FakeStreamingMemory:
+    def __init__(self):
+        self.sessions = []
+        self.session_service = object()
+
+    async def create_session(self, app_name, user_id, session_id):
+        self.sessions.append(
+            {"app_name": app_name, "user_id": user_id, "session_id": session_id}
+        )
+        return True
+
+
+class FakeStreamingRunner:
+    def __init__(self):
+        self.app_name = "stream_app"
+        self.short_term_memory = FakeStreamingMemory()
+        self.run_async_calls = []
+
+    async def run_async(self, user_id, session_id, new_message, run_config=None):
+        self.run_async_calls.append(
+            {
+                "user_id": user_id,
+                "session_id": session_id,
+                "new_message": new_message,
+                "run_config": run_config,
+            }
+        )
+        yield SimpleNamespace(
+            content=SimpleNamespace(
+                parts=[
+                    SimpleNamespace(text="hel", thought=False),
+                    SimpleNamespace(text="thinking", thought=True),
+                ]
+            )
+        )
+        yield SimpleNamespace(
+            content=SimpleNamespace(parts=[SimpleNamespace(text="lo", thought=False)])
+        )
+
+
 def build_message(**overrides):
     message = SimpleNamespace(
         id="om_001",
@@ -73,7 +137,7 @@ def build_message(**overrides):
     return message
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_extension_uses_union_id_and_thread_id():
     runner = FakeRunner()
     channel = FakeChannel()
@@ -102,7 +166,7 @@ async def test_extension_uses_union_id_and_thread_id():
     ]
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_extension_falls_back_to_chat_id_when_thread_missing():
     runner = FakeRunner()
     channel = FakeChannel()
@@ -118,7 +182,7 @@ async def test_extension_falls_back_to_chat_id_when_thread_missing():
     assert runner.calls[0]["session_id"] == "oc_chat"
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_extension_ignores_empty_message_by_default():
     runner = FakeRunner()
     channel = FakeChannel()
@@ -130,3 +194,26 @@ async def test_extension_ignores_empty_message_by_default():
 
     assert runner.calls == []
     assert channel.sent_messages == []
+
+
+@pytest.mark.anyio
+async def test_extension_streaming_uses_markdown_producer_controller():
+    runner = FakeStreamingRunner()
+    channel = FakeStreamChannel()
+    extension = FeishuChannelExtension(
+        runner=runner,
+        channel=channel,
+        streaming=True,
+    )
+
+    await extension._on_message(build_message())
+
+    assert runner.short_term_memory.sessions == [
+        {
+            "app_name": "stream_app",
+            "user_id": "on_union",
+            "session_id": "oc_chat",
+        }
+    ]
+    assert len(runner.run_async_calls) == 1
+    assert channel.stream_calls == [("oc_chat", ["hel", "lo"], {"reply_to": "om_001"})]

{veadk_python-0.5.33 → veadk_python-0.5.35}/veadk/agent.py

@@ -313,7 +313,9 @@ class Agent(LlmAgent):
             self.load_skills()
             if self.enable_skills_checklist:
                 logger.info("Skills checklist enabled")
-                from veadk.skills.utils import create_init_skill_check_list_callback
+                from veadk.skills.utils import (
+                    create_init_skill_check_list_callback,
+                )
 
                 init_callback = create_init_skill_check_list_callback(
                     self._skills_with_checklist
@@ -374,8 +376,8 @@ class Agent(LlmAgent):
     def load_skills(self):
         from pathlib import Path
 
-        from veadk.skills.skill import Skill
         from veadk.skills.check_skills_callback import check_skills
+        from veadk.skills.skill import Skill
         from veadk.skills.utils import (
             load_skills_from_cloud,
             load_skills_from_directory,
@@ -390,8 +392,10 @@ class Agent(LlmAgent):
             if not tool_id:
                 self.skills_mode = "local"
             else:
+                from veadk.auth.veauth.utils import (
+                    get_credential_from_vefaas_iam,
+                )
                 from veadk.utils.volcengine_sign import ve_request
-                from veadk.auth.veauth.utils import get_credential_from_vefaas_iam
 
                 ak = os.getenv("VOLCENGINE_ACCESS_KEY")
                 sk = os.getenv("VOLCENGINE_SECRET_KEY")
@@ -419,7 +423,8 @@ class Agent(LlmAgent):
                 service = os.getenv("AGENTKIT_TOOL_SERVICE_CODE", "agentkit")
                 region = os.getenv("AGENTKIT_TOOL_REGION", default_region)
                 host = os.getenv(
-                    "AGENTKIT_SKILL_HOST", service + "." + region + f".{sld}.com"
+                    "AGENTKIT_SKILL_HOST",
+                    service + "." + region + f".{sld}.com",
                 )
 
                 res = ve_request(
@@ -528,7 +533,9 @@ class Agent(LlmAgent):
         has_video_task_query = "video_task_query" in tool_names
 
         if has_video_generate and not has_video_task_query:
-            from veadk.tools.builtin_tools.video_generate import video_task_query
+            from veadk.tools.builtin_tools.video_generate import (
+                video_task_query,
+            )
 
             logger.warning(
                 "video_generate tool is mounted but video_task_query is not. "
@@ -623,7 +630,7 @@ class Agent(LlmAgent):
                 return SupervisorAutoFlow(supervised_agent=self)
             return AutoFlow()
 
-    async def run(self, **kwargs):
-        raise NotImplementedError(
-            "Run method in VeADK agent is deprecated since version 0.5.6. Please use runner.run_async instead. Ref: https://agentkit.gitbook.io/docs/runner/overview"
-        )
+    # async def run(self, **kwargs):
+    #     raise NotImplementedError(
+    #         "Run method in VeADK agent is deprecated since version 0.5.6. Please use runner.run_async instead. Ref: https://agentkit.gitbook.io/docs/runner/overview"
+    #     )

veadk_python-0.5.35/veadk/community/langchain_ai/tools/execute_skills.py

@@ -0,0 +1,100 @@
+# 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 typing import List, Optional
+
+from langchain.tools import ToolRuntime, tool
+
+from veadk.tools.builtin_tools._agentkit import (
+    get_agentkit_account_id,
+    resolve_agentkit_tool_id,
+)
+from veadk.tools.builtin_tools.run_sandbox_agent import (
+    _format_execution_result,
+    _build_agent_command,
+    _build_agent_runner_code,
+)
+from veadk.utils.logger import get_logger
+from veadk.tools.builtin_tools._agentkit import (
+    get_agentkit_endpoint_config,
+    invoke_agentkit_run_code,
+)
+
+logger = get_logger(__name__)
+
+
+@tool
+def execute_skills(
+    workflow_prompt: str,
+    runtime: ToolRuntime,
+    skills: Optional[List[str]] = None,
+    timeout: int = 900,
+) -> str:
+    """execute skills in a code sandbox and return the output.
+    For C++ code, don't execute it directly, compile and execute via Python; write sources and object files to /tmp.
+
+    Args:
+        workflow_prompt (str): instruction of workflow
+        skills (Optional[List[str]]): The skills will be invoked
+        timeout (int, optional): The timeout in seconds for the code execution, less than or equal to 900. Defaults to 900.
+
+    Returns:
+        str: The output of the code execution.
+    """
+
+    tool_id = resolve_agentkit_tool_id("AGENTKIT_TOOL_ID_SKILLS")
+    service, region, host, _ = get_agentkit_endpoint_config()
+    logger.debug(f"tools endpoint: {host}")
+
+    session_id = runtime.session_id  # type: ignore
+    agent_name = runtime.context.agent_name  # type: ignore
+    user_id = runtime.context.user_id  # type: ignore
+    tool_user_session_id = agent_name + "_" + user_id + "_" + session_id
+    logger.debug(f"tool_user_session_id: {tool_user_session_id}")
+
+    logger.debug(
+        f"Execute skills in session_id={session_id}, tool_id={tool_id}, host={host}, service={service}, region={region}, timeout={timeout}"
+    )
+
+    cmd = _build_agent_command(workflow_prompt=workflow_prompt, skills=skills)
+    try:
+        account_id = get_agentkit_account_id()
+    except KeyError as e:
+        logger.error(f"Error occurred while getting account id: {e}")
+        return {"error": str(e)}
+
+    env_vars = {"TOOL_USER_SESSION_ID": tool_user_session_id}
+    if account_id:
+        env_vars["TOS_SKILLS_DIR"] = f"tos://agentkit-platform-{account_id}/skills/"
+
+    code = _build_agent_runner_code(
+        cmd=cmd,
+        timeout=timeout,
+        env_vars=env_vars,
+    )
+
+    res = invoke_agentkit_run_code(
+        tool_id=tool_id,
+        tool_user_session_id=tool_user_session_id,
+        code=code,
+        timeout=timeout,
+        kernel_name="python3",
+    )
+    logger.debug(f"Invoke run code response: {res}")
+
+    try:
+        return _format_execution_result(res["Result"]["Result"])
+    except KeyError as e:
+        logger.error(f"Error occurred while running code: {e}, response is {res}")
+        return res

{veadk_python-0.5.33 → veadk_python-0.5.35}/veadk/community/langchain_ai/tools/run_code.py

@@ -12,15 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
-import os
-
 from langchain.tools import ToolRuntime, tool
 
-from veadk.auth.veauth.utils import get_credential_from_vefaas_iam
-from veadk.config import getenv
+from veadk.tools.builtin_tools._agentkit import (
+    get_agentkit_endpoint_config,
+    invoke_agentkit_run_code,
+    resolve_agentkit_tool_id,
+)
 from veadk.utils.logger import get_logger
-from veadk.utils.volcengine_sign import ve_request
 
 logger = get_logger(__name__)
 
@@ -39,18 +38,8 @@ def run_code(code: str, language: str, runtime: ToolRuntime, timeout: int = 30)
         str: The output of the code execution.
     """
 
-    tool_id = getenv("AGENTKIT_TOOL_ID")
-
-    service = getenv(
-        "AGENTKIT_TOOL_SERVICE_CODE", "agentkit"
-    )  # temporary service for code run tool
-    region = getenv("AGENTKIT_TOOL_REGION", "cn-beijing")
-    host = getenv(
-        "AGENTKIT_TOOL_HOST", service + "." + region + ".volces.com"
-    )  # temporary host for code run tool
-    scheme = os.getenv("AGENTKIT_TOOL_SCHEME", "https").lower()
-    if scheme not in {"http", "https"}:
-        scheme = "https"
+    tool_id = resolve_agentkit_tool_id("AGENTKIT_TOOL_ID_SCRIPT")
+    service, region, host, _ = get_agentkit_endpoint_config()
     logger.debug(f"tools endpoint: {host}")
 
     session_id = runtime.context.session_id  # type: ignore
@@ -64,44 +53,12 @@ def run_code(code: str, language: str, runtime: ToolRuntime, timeout: int = 30)
         f"Running code in language: {language}, session_id={session_id}, code={code}, tool_id={tool_id}, host={host}, service={service}, region={region}, timeout={timeout}"
     )
 
-    header = {}
-
-    logger.debug("Get AK/SK from tool context failed.")
-    ak = os.getenv("VOLCENGINE_ACCESS_KEY")
-    sk = os.getenv("VOLCENGINE_SECRET_KEY")
-    if not (ak and sk):
-        logger.debug(
-            "Get AK/SK from environment variables failed. Try to use credential from Iam."
-        )
-        credential = get_credential_from_vefaas_iam()
-        ak = credential.access_key_id
-        sk = credential.secret_access_key
-        header = {"X-Security-Token": credential.session_token}
-    else:
-        logger.debug("Successfully get AK/SK from environment variables.")
-
-    res = ve_request(
-        request_body={
-            "ToolId": tool_id,
-            "UserSessionId": tool_user_session_id,
-            "OperationType": "RunCode",
-            "OperationPayload": json.dumps(
-                {
-                    "code": code,
-                    "timeout": timeout,
-                    "kernel_name": language,
-                }
-            ),
-        },
-        action="InvokeTool",
-        ak=ak,
-        sk=sk,
-        service=service,
-        version="2025-10-30",
-        region=region,
-        host=host,
-        header=header,
-        scheme=scheme,  # type: ignore
+    res = invoke_agentkit_run_code(
+        tool_id=tool_id,
+        tool_user_session_id=tool_user_session_id,
+        code=code,
+        timeout=timeout,
+        kernel_name=language,
     )
     logger.debug(f"Invoke run code response: {res}")
 

{veadk_python-0.5.33 → veadk_python-0.5.35}/veadk/extensions/feishu_channel.py

@@ -60,6 +60,9 @@ class FeishuMessageContext:
     text: str
 
 
+FEISHU_EMOJI_ONE_SECOND = "OneSecond"
+
+
 class FeishuChannelExtension:
     """Bridge a Feishu bot channel with a VeADK runner.
 
@@ -84,6 +87,8 @@ class FeishuChannelExtension:
         reply_in_thread: bool = True,
         ignore_empty_messages: bool = True,
         channel_kwargs: dict[str, Any] | None = None,
+        streaming: bool = False,
+        reactions: bool = False,
     ) -> None:
         self.runner = runner
         self.session_id_factory = session_id_factory or self.default_session_id_factory
@@ -92,6 +97,14 @@ class FeishuChannelExtension:
         self.response_formatter = response_formatter or self.default_response_formatter
         self.reply_in_thread = reply_in_thread
         self.ignore_empty_messages = ignore_empty_messages
+        self.reactions = (
+            reactions
+            or str(os.getenv("TOOL_FEISHU_CHANNEL_REACTIONS", "")).lower() == "true"
+        )
+        self.streaming = (
+            streaming
+            or str(os.getenv("TOOL_FEISHU_CHANNEL_STREAMING", "")).lower() == "true"
+        )
 
         if channel is not None:
             self.channel = channel
@@ -167,8 +180,100 @@ class FeishuChannelExtension:
 
         context = self.build_message_context(message=message, text=text)
 
+        if self.reactions and context.message_id:
+            try:
+                import lark_oapi.api.im.v1 as lark_im
+
+                emoji = (
+                    lark_im.Emoji.builder().emoji_type(FEISHU_EMOJI_ONE_SECOND).build()
+                )
+                request = (
+                    lark_im.CreateMessageReactionRequest.builder()
+                    .message_id(context.message_id)
+                    .request_body(
+                        lark_im.CreateMessageReactionRequestBody.builder()
+                        .reaction_type(emoji)
+                        .build()
+                    )
+                    .build()
+                )
+
+                if hasattr(self.channel, "client"):
+                    response = await self._maybe_await(
+                        self.channel.client.im.v1.message_reaction.create(request)
+                    )
+
+                    if not response.success():
+                        logger.error(
+                            f"Failed to add reaction to message {context.message_id}: {response.code} {response.msg}"
+                        )
+                else:
+                    logger.warning(
+                        "Channel has no client attribute, cannot send reaction"
+                    )
+            except Exception as e:
+                logger.error(
+                    f"Failed to add reaction to message {context.message_id}: {e}"
+                )
+
+        send_options = {}
+        if self.reply_in_thread and context.message_id:
+            send_options["reply_to"] = context.message_id
+
         if self.message_handler is not None:
             response_text = await self._maybe_await(self.message_handler(context))
+            if not response_text:
+                return
+
+            await self._maybe_await(
+                self.channel.send(
+                    context.chat_id,
+                    self.response_formatter(str(response_text)),
+                    send_options,
+                )
+            )
+        elif getattr(self, "streaming", False) and hasattr(self.channel, "stream"):
+            from google.adk.agents import RunConfig
+            from google.adk.agents.run_config import StreamingMode
+            from veadk.config import getenv
+            from veadk.runner import _convert_messages
+
+            if self.runner.short_term_memory:
+                await self.runner.short_term_memory.create_session(
+                    app_name=self.runner.app_name,
+                    user_id=context.user_id,
+                    session_id=context.session_id,
+                )
+
+            converted_messages = _convert_messages(
+                context.text, self.runner.app_name, context.user_id, context.session_id
+            )
+
+            run_config = RunConfig(
+                streaming_mode=StreamingMode.SSE,
+                max_llm_calls=int(getenv("MODEL_AGENT_MAX_LLM_CALLS", 100)),
+            )
+
+            async def stream_to_feishu(stream):
+                for converted_message in converted_messages:
+                    async for event in self.runner.run_async(
+                        user_id=context.user_id,
+                        session_id=context.session_id,
+                        new_message=converted_message,
+                        run_config=run_config,
+                    ):
+                        if event.content and event.content.parts:
+                            for part in event.content.parts:
+                                if not getattr(part, "thought", False) and part.text:
+                                    await stream.append(part.text)
+
+            await self._maybe_await(
+                self.channel.stream(
+                    context.chat_id,
+                    {"markdown": stream_to_feishu},
+                    send_options,
+                )
+            )
         else:
             response_text = await self.runner.run(
                 messages=context.text,
@@ -176,20 +281,16 @@ class FeishuChannelExtension:
                 session_id=context.session_id,
             )
 
-        if not response_text:
-            return
-
-        send_options = {}
-        if self.reply_in_thread and context.message_id:
-            send_options["reply_to"] = context.message_id
+            if not response_text:
+                return
 
-        await self._maybe_await(
-            self.channel.send(
-                context.chat_id,
-                self.response_formatter(str(response_text)),
-                send_options,
+            await self._maybe_await(
+                self.channel.send(
+                    context.chat_id,
+                    self.response_formatter(str(response_text)),
+                    send_options,
+                )
             )
-        )
 
     def build_message_context(
         self, message: Any, text: str | None = None