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

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

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

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

{veadk_python-0.5.33 → veadk_python-0.5.34}/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.34/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.34}/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.34}/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

veadk_python-0.5.34/veadk/tools/builtin_tools/_agentkit.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+from typing import Any, Optional
+
+from veadk.auth.veauth.utils import get_credential_from_vefaas_iam
+from veadk.config import getenv
+from veadk.utils.logger import get_logger
+from veadk.utils.volcengine_sign import ve_request
+
+logger = get_logger(__name__)
+
+
+def resolve_agentkit_tool_id(*preferred_env_names: str) -> str:
+    """Resolve the first configured AgentKit tool id with AGENTKIT_TOOL_ID fallback."""
+    for env_name in [*preferred_env_names, "AGENTKIT_TOOL_ID"]:
+        tool_id = os.getenv(env_name)
+        if tool_id:
+            return tool_id
+
+    return getenv("AGENTKIT_TOOL_ID")
+
+
+def get_agentkit_endpoint_config(
+    host_env_name: str = "AGENTKIT_TOOL_HOST",
+) -> tuple[str, str, str, str]:
+    """Return service, region, host and scheme for AgentKit tool invocation."""
+    service = getenv("AGENTKIT_TOOL_SERVICE_CODE", "agentkit")
+
+    cloud_provider = (os.getenv("CLOUD_PROVIDER") or "").lower()
+    if cloud_provider == "byteplus":
+        sld = "bytepluses"
+        default_region = "ap-southeast-1"
+    else:
+        sld = "volces"
+        default_region = "cn-beijing"
+
+    region = getenv("AGENTKIT_TOOL_REGION", default_region)
+    host = getenv(host_env_name, service + "." + region + f".{sld}.com")
+    scheme = getenv("AGENTKIT_TOOL_SCHEME", "https", allow_false_values=True).lower()
+    if scheme not in {"http", "https"}:
+        scheme = "https"
+
+    return service, region, host, scheme
+
+
+def get_agentkit_credentials(
+    tool_state: Optional[dict[str, Any]] = None,
+) -> tuple[str, str, dict[str, str]]:
+    """Resolve AgentKit invocation credentials from tool state, env, or IAM."""
+    ak = tool_state.get("VOLCENGINE_ACCESS_KEY") if tool_state else None
+    sk = tool_state.get("VOLCENGINE_SECRET_KEY") if tool_state else None
+    header: dict[str, str] = {}
+
+    if not (ak and sk):
+        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.")
+    else:
+        logger.debug("Successfully get AK/SK from tool context.")
+
+    return ak, sk, header
+
+
+def get_agentkit_account_id(tool_state: Optional[dict[str, Any]] = None) -> str:
+    """Get the current caller account id for remote skills sandbox setup."""
+    cloud_provider = (os.getenv("CLOUD_PROVIDER") or "").lower()
+    if cloud_provider == "vestack":
+        return ""
+
+    _, region, _, _ = get_agentkit_endpoint_config()
+    ak, sk, header = get_agentkit_credentials(tool_state)
+    host = (
+        "open.byteplusapi.com"
+        if cloud_provider == "byteplus"
+        else "sts.volcengineapi.com"
+    )
+    res = ve_request(
+        request_body={},
+        action="GetCallerIdentity",
+        ak=ak,
+        sk=sk,
+        service="sts",
+        version="2018-01-01",
+        region=region,
+        host=host,
+        header=header,
+    )
+    return res["Result"]["AccountId"]
+
+
+def invoke_agentkit_run_code(
+    *,
+    tool_id: str,
+    tool_user_session_id: str,
+    code: str,
+    timeout: int,
+    kernel_name: str,
+    tool_state: Optional[dict[str, Any]] = None,
+    ttl: Optional[int] = None,
+) -> dict[str, Any]:
+    """Invoke the AgentKit RunCode operation."""
+    service, region, host, scheme = get_agentkit_endpoint_config()
+    ak, sk, header = get_agentkit_credentials(tool_state)
+
+    request_body: dict[str, Any] = {
+        "ToolId": tool_id,
+        "UserSessionId": tool_user_session_id,
+        "OperationType": "RunCode",
+        "OperationPayload": json.dumps(
+            {
+                "code": code,
+                "timeout": timeout,
+                "kernel_name": kernel_name,
+            }
+        ),
+    }
+    if ttl is not None:
+        request_body["Ttl"] = ttl
+
+    return ve_request(
+        request_body=request_body,
+        action="InvokeTool",
+        ak=ak,
+        sk=sk,
+        service=service,
+        version="2025-10-30",
+        region=region,
+        host=host,
+        header=header,
+        scheme=scheme,
+    )