veadk-python 0.2.31__tar.gz → 0.2.33__tar.gz

{veadk_python-0.2.31 → veadk_python-0.2.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veadk-python
-Version: 0.2.31
+Version: 0.2.33
 Summary: Volcengine agent development kit, integrations with Volcengine cloud services.
 Author-email: Yaozheng Fang <fangyozheng@gmail.com>, Guodong Li <cu.eric.lee@gmail.com>, Zhi Han <sliverydayday@gmail.com>, Meng Wang <mengwangwm@gmail.com>
 License:                                  Apache License

{veadk_python-0.2.31 → veadk_python-0.2.33}/pyproject.toml

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

{veadk_python-0.2.31 → veadk_python-0.2.33}/veadk/cli/cli_create.py

@@ -12,10 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import click
 import shutil
 from pathlib import Path
 
+import click
+
 _ENV_TEMPLATE = """\
 MODEL_AGENT_API_KEY={ark_api_key}
 """
@@ -31,7 +32,7 @@ root_agent = Agent(
     name="root_agent",
     description="A helpful assistant for user questions.",
     instruction="Answer user questions to the best of your knowledge",
-    model_name="doubao-seed-1-6-251015", # <---- you can change your model here
+    model_name="doubao-seed-1-8-251215", # <---- change model here
 )
 """
 

{veadk_python-0.2.31 → veadk_python-0.2.33}/veadk/config.py

@@ -19,6 +19,7 @@ from dotenv import find_dotenv, load_dotenv, dotenv_values
 from pydantic import BaseModel, Field
 
 from veadk.configs.auth_configs import VeIdentityConfig
+from veadk.configs.model_configs import RealtimeModelConfig
 from veadk.configs.database_configs import (
     MysqlConfig,
     OpensearchConfig,
@@ -70,6 +71,7 @@ class VeADKConfig(BaseModel):
     )
 
     veidentity: VeIdentityConfig = Field(default_factory=VeIdentityConfig)
+    realtime_model: RealtimeModelConfig = Field(default_factory=RealtimeModelConfig)
 
 
 def getenv(

{veadk_python-0.2.31 → veadk_python-0.2.33}/veadk/configs/database_configs.py

@@ -130,3 +130,47 @@ class NormalTOSConfig(BaseSettings):
     region: str = "cn-beijing"
 
     bucket: str
+
+
+class TOSVectorConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="DATABASE_TOS_VECTOR_")
+
+    endpoint: str = "tosvectors-cn-beijing.volces.com"
+
+    region: str = "cn-beijing"
+
+    security_token: str | None = None
+
+    max_retry_count: int = 3
+
+    max_connections: int = 1024
+
+    connection_time: int = 10
+
+    enable_verify_ssl: bool = True
+
+    dns_cache_time: int = 15
+
+    proxy_host: str | None = None
+
+    proxy_port: int | None = None
+
+    proxy_username: str | None = None
+
+    proxy_password: str | None = None
+
+    high_latency_log_threshold: int = 100
+
+    socket_timeout: int = 30
+
+    credentials_provider: object | None = None
+
+    except100_continue_threshold: int = 65536
+
+    user_agent_product_name: str | None = None
+
+    user_agent_soft_name: str | None = None
+
+    user_agent_soft_version: str | None = None
+
+    user_agent_customized_key_values: dict[str, str] | None = None

{veadk_python-0.2.31 → veadk_python-0.2.33}/veadk/configs/model_configs.py

@@ -18,6 +18,7 @@ from functools import cached_property
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from veadk.auth.veauth.ark_veauth import get_ark_token
+from veadk.auth.veauth.speech_veauth import get_speech_token
 from veadk.consts import (
     DEFAULT_MODEL_AGENT_API_BASE,
     DEFAULT_MODEL_AGENT_NAME,
@@ -76,3 +77,17 @@ class NormalEmbeddingModelConfig(BaseSettings):
     """The api base of the model for embedding."""
 
     api_key: str
+
+
+class RealtimeModelConfig(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="MODEL_REALTIME_")
+
+    name: str = "doubao_realtime_voice_model"
+    """Model name for realtime."""
+
+    api_base: str = "wss://openspeech.bytedance.com/api/v3/realtime/dialogue"
+    """The api base of the model for realtime."""
+
+    @cached_property
+    def api_key(self) -> str:
+        return os.getenv("MODEL_REALTIME_API_KEY") or get_speech_token()

veadk_python-0.2.33/veadk/knowledgebase/backends/tos_vector_backend.py

@@ -0,0 +1,190 @@
+# 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 llama_index.core import (
+    Document,
+    SimpleDirectoryReader,
+)
+from llama_index.core.schema import BaseNode
+from llama_index.embeddings.openai_like import OpenAILikeEmbedding
+from pydantic import Field
+from typing_extensions import Any, override
+
+import veadk.config  # noqa E401
+from veadk.configs.database_configs import TOSVectorConfig
+from veadk.configs.model_configs import EmbeddingModelConfig, NormalEmbeddingModelConfig
+
+from veadk.knowledgebase.backends.base_backend import BaseKnowledgebaseBackend
+from veadk.knowledgebase.backends.utils import get_llama_index_splitter
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+try:
+    from tos.vector_client import VectorClient
+    from tos import DataType, DistanceMetricType
+    from tos.exceptions import TosServerError
+    from tos.models2 import Vector, VectorData
+except ImportError:
+    raise ImportError(
+        "Please install VeADK extensions\npip install veadk-python[extensions]"
+    )
+
+
+class TosVectorKnowledgeBackend(BaseKnowledgebaseBackend):
+    """TOS-based backend for knowledgebase."""
+
+    volcengine_access_key: str | None = Field(
+        default_factory=lambda: os.getenv("VOLCENGINE_ACCESS_KEY")
+    )
+    volcengine_secret_key: str | None = Field(
+        default_factory=lambda: os.getenv("VOLCENGINE_SECRET_KEY")
+    )
+    tos_vector_bucket_name: str | None = Field(
+        default_factory=lambda: os.getenv("DATABASE_TOS_VECTOR_BUCKET")
+    )
+    tos_vector_account_id: str | None = Field(
+        default_factory=lambda: os.getenv("DATABASE_TOS_VECTOR_ACCOUNT_ID")
+    )
+    tos_vector_config: TOSVectorConfig = Field(default_factory=TOSVectorConfig)
+
+    session_token: str = ""
+
+    embedding_config: EmbeddingModelConfig | NormalEmbeddingModelConfig = Field(
+        default_factory=EmbeddingModelConfig
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        self.precheck_index_naming()
+        self._tos_vector_client = VectorClient(
+            ak=self.volcengine_access_key,
+            sk=self.volcengine_secret_key,
+            **self.tos_vector_config.model_dump(),
+        )
+        # create_bucket and index if not exist
+        self._create_index()
+
+        self._embed_model = OpenAILikeEmbedding(
+            model_name=self.embedding_config.name,
+            api_key=self.embedding_config.api_key,
+            api_base=self.embedding_config.api_base,
+        )
+
+    def _index_exists(self) -> bool:
+        try:
+            index_exist = self._tos_vector_client.get_index(
+                vector_bucket_name=self.tos_vector_bucket_name,
+                account_id=self.tos_vector_account_id,
+                index_name=self.index,
+            )
+            return index_exist.status_code == 200
+        except TosServerError as e:
+            if e.status_code == 404:
+                return False
+            else:
+                raise e
+
+    def _split_documents(self, documents: list[Document]) -> list[BaseNode]:
+        """Split document into chunks"""
+        nodes = []
+        for document in documents:
+            splitter = get_llama_index_splitter(document.metadata.get("file_path", ""))
+            _nodes = splitter.get_nodes_from_documents([document])
+            nodes.extend(_nodes)
+        return nodes
+
+    def _create_index(self):
+        # no need to check if bucket exists, create_bucket will create it if not exist
+        self._tos_vector_client.create_vector_bucket(
+            vector_bucket_name=self.tos_vector_bucket_name,
+        )
+
+        if not self._index_exists():
+            self._tos_vector_client.create_index(
+                vector_bucket_name=self.tos_vector_bucket_name,
+                account_id=self.tos_vector_account_id,
+                index_name=self.index,
+                data_type=DataType.DataTypeFloat32,
+                dimension=self.embedding_config.dim,
+                distance_metric=DistanceMetricType.DistanceMetricCosine,
+            )
+
+    def precheck_index_naming(self) -> None:
+        pass
+
+    def _process_and_store_documents(self, documents: list[Document]) -> bool:
+        nodes = self._split_documents(documents)
+        vectors = []
+        for node in nodes:
+            if not node.text:
+                continue
+            embedding = self._embed_model.get_text_embedding(node.text)
+            vectors.append(
+                Vector(
+                    key=node.node_id,
+                    data=VectorData(float32=embedding),
+                    metadata={"text": node.text, "metadata": json.dumps(node.metadata)},
+                )
+            )
+        result = self._tos_vector_client.put_vectors(
+            vector_bucket_name=self.tos_vector_bucket_name,
+            account_id=self.tos_vector_account_id,
+            index_name=self.index,
+            vectors=vectors,
+        )
+        return result.status_code == 200
+
+    @override
+    def add_from_directory(self, directory: str, *args, **kwargs) -> bool:
+        # fixme
+        logger.warning(
+            "add_from_directory is not yet fully developed and may have issues such as missing images."
+        )
+        documents = SimpleDirectoryReader(input_dir=directory).load_data()
+        return self._process_and_store_documents(documents)
+
+    @override
+    def add_from_files(self, files: list[str], *args, **kwargs) -> bool:
+        # fixme
+        logger.warning(
+            "add_from_files is not yet fully developed and may have issues such as missing images."
+        )
+        documents = SimpleDirectoryReader(input_files=files).load_data()
+        return self._process_and_store_documents(documents)
+
+    @override
+    def add_from_text(self, text: str | list[str], *args, **kwargs) -> bool:
+        if isinstance(text, str):
+            documents = [Document(text=text)]
+        else:
+            documents = [Document(text=t) for t in text]
+
+        return self._process_and_store_documents(documents)
+
+    @override
+    def search(self, query: str, top_k: int = 5) -> list[str]:
+        query_vector = self._embed_model.get_text_embedding(query)
+
+        search_result = self._tos_vector_client.query_vectors(
+            vector_bucket_name=self.tos_vector_bucket_name,
+            account_id=self.tos_vector_account_id,
+            index_name=self.index,
+            query_vector=VectorData(float32=query_vector),
+            top_k=top_k,
+            return_metadata=True,
+        )
+
+        return [vector.metadata["text"] for vector in search_result.vectors]

{veadk_python-0.2.31 → veadk_python-0.2.33}/veadk/knowledgebase/knowledgebase.py

@@ -51,6 +51,12 @@ def _get_backend_cls(backend: str) -> type[BaseKnowledgebaseBackend]:
             )
 
             return RedisKnowledgeBackend
+        case "tos_vector":
+            from veadk.knowledgebase.backends.tos_vector_backend import (
+                TosVectorKnowledgeBackend,
+            )
+
+            return TosVectorKnowledgeBackend
 
     raise ValueError(f"Unsupported knowledgebase backend: {backend}")
 
@@ -165,7 +171,8 @@ class KnowledgeBase(BaseModel):
     description: str = "This knowledgebase stores some user-related information."
 
     backend: Union[
-        Literal["local", "opensearch", "viking", "redis"], BaseKnowledgebaseBackend
+        Literal["local", "opensearch", "viking", "redis", "tos_vector"],
+        BaseKnowledgebaseBackend,
     ] = "local"
 
     backend_config: dict = Field(default_factory=dict)

veadk_python-0.2.33/veadk/realtime/__init__.py

@@ -0,0 +1,22 @@
+# 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 .doubao_realtime_voice_llm import DoubaoRealtimeVoice
+from google.adk.models.registry import LLMRegistry
+
+__all__ = [
+    "DoubaoRealtimeVoice",
+]
+
+LLMRegistry.register(DoubaoRealtimeVoice)

veadk_python-0.2.33/veadk/realtime/client.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from google.genai.client import Client, AsyncClient
+from google.genai._api_client import BaseApiClient
+from .live import DoubaoAsyncLive
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class DoubaoAsyncClient(AsyncClient):
+    """Client for making asynchronous (non-blocking) requests."""
+
+    def __init__(self, api_client: BaseApiClient):
+        super().__init__(api_client)
+        self._live = DoubaoAsyncLive(self._api_client)
+
+    @property
+    def live(self) -> DoubaoAsyncLive:
+        return self._live
+
+
+class DoubaoClient(Client):
+    """The synchronous client for doubao realtime voice model, with async support via the aio property."""
+
+    def __init__(self, *args, **kwargs):
+        # Temporary workaround to set Google API key for Gemini client
+        if not os.environ.get("GOOGLE_API_KEY"):
+            os.environ["GOOGLE_API_KEY"] = "hack_google_api_key"
+        try:
+            super().__init__(*args, **kwargs)
+            self._aio = DoubaoAsyncClient(self._api_client)
+        except Exception as e:
+            logger.info(f"Failed to initialize DoubaoAsyncClient: {e}")
+            self._aio = None
+
+    @property
+    def aio(self) -> DoubaoAsyncClient:
+        return self._aio

veadk_python-0.2.33/veadk/realtime/doubao_realtime_voice_llm.py

@@ -0,0 +1,166 @@
+# 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 contextlib
+from functools import cached_property
+import os
+import sys
+
+from typing import Optional
+from typing import TYPE_CHECKING
+
+
+from .client import DoubaoClient
+from google.genai import types
+from typing_extensions import override
+from google.adk import version
+from google.adk.models.google_llm import Gemini
+from google.adk.models.base_llm_connection import BaseLlmConnection
+from .doubao_realtime_voice_llm_connection import DoubaoRealtimeVoiceLlmConnection
+
+
+if TYPE_CHECKING:
+    from google.adk.models.llm_request import LlmRequest
+
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+_NEW_LINE = "\n"
+_EXCLUDED_PART_FIELD = {"inline_data": {"data"}}
+_AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine"
+_AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "VOLCENGINE_CLOUD_AGENT_ENGINE_ID"
+
+
+class DoubaoRealtimeVoice(Gemini):
+    """Integration for doubao realtime voice model.
+
+    Attributes:
+      model: The name of the doubao realtime voice model (default: 'doubao_realtime_voice').
+      speech_config: Optional speech configuration for voice input/output (type: google.genai.types.SpeechConfig).
+      retry_options: Optional HTTP retry configuration for failed requests (type: google.genai.types.HttpRetryOptions).
+    """
+
+    model: str = "doubao_realtime_voice"
+
+    speech_config: Optional[types.SpeechConfig] = None
+
+    retry_options: Optional[types.HttpRetryOptions] = None
+    """Allow doubao realtime voice model to retry failed responses.
+  
+    Sample:
+    ```python
+    from google.genai import types
+  
+    # ...
+  
+    agent = Agent(
+      model=DoubaoRealtimeVoice(
+        retry_options=types.HttpRetryOptions(initial_delay=1, attempts=2),
+      )
+    )
+    ```
+    """
+
+    @classmethod
+    @override
+    def supported_models(cls) -> list[str]:
+        """Provides the list of supported models.
+
+        Returns:
+          A list of supported models.
+        """
+
+        return [
+            r"doubao_realtime_voice.*",
+            r"Doubao_scene_SLM_Doubao_realtime_voice_model.*",
+        ]
+
+    @cached_property
+    def api_client(self) -> DoubaoClient:
+        """Provides the api client.
+
+        Returns:
+          The api client.
+        """
+        return DoubaoClient(
+            http_options=types.HttpOptions(
+                headers=self._tracking_headers,
+                retry_options=self.retry_options,
+            )
+        )
+
+    @cached_property
+    def _live_api_client(self) -> DoubaoClient:
+        return DoubaoClient(
+            http_options=types.HttpOptions(
+                headers=self._tracking_headers, api_version=self._live_api_version
+            )
+        )
+
+    @cached_property
+    def _tracking_headers(self) -> dict[str, str]:
+        framework_label = f"veadk/{version.__version__}"
+        if os.environ.get(_AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME):
+            framework_label = f"{framework_label}+{_AGENT_ENGINE_TELEMETRY_TAG}"
+        language_label = "ve-python/" + sys.version.split()[0]
+        version_header_value = f"{framework_label} {language_label}"
+        tracking_headers = {
+            "x-volcengine-api-client": version_header_value,
+            "user-agent": version_header_value,
+        }
+        return tracking_headers
+
+    @contextlib.asynccontextmanager
+    async def connect(self, llm_request: LlmRequest) -> BaseLlmConnection:
+        """Connects to the doubao realtime voice LLM model and returns an llm connection.
+
+        Args:
+          llm_request: LlmRequest, the request to send to the Seed LLM model.
+
+        Yields:
+          BaseLlmConnection, the connection to the Seed LLM model.
+        """
+        # add tracking headers to custom headers and set api_version given
+        # the customized http options will override the one set in the api client
+        # constructor
+        if (
+            llm_request.live_connect_config
+            and llm_request.live_connect_config.http_options
+        ):
+            if not llm_request.live_connect_config.http_options.headers:
+                llm_request.live_connect_config.http_options.headers = {}
+            llm_request.live_connect_config.http_options.headers.update(
+                self._tracking_headers
+            )
+            llm_request.live_connect_config.http_options.api_version = (
+                self._live_api_version
+            )
+
+        if self.speech_config is not None:
+            llm_request.live_connect_config.speech_config = self.speech_config
+
+        llm_request.live_connect_config.system_instruction = types.Content(
+            role="system",
+            parts=[types.Part.from_text(text=llm_request.config.system_instruction)],
+        )
+        llm_request.live_connect_config.tools = llm_request.config.tools
+        logger.info("Connecting to live with llm_request:%s", llm_request)
+        async with self._live_api_client.aio.live.connect(
+            model=llm_request.model, config=llm_request.live_connect_config
+        ) as live_session:
+            # use DoubaoRealtimeVoiceLlmConnection in place of GeminiLlmConnection
+            yield DoubaoRealtimeVoiceLlmConnection(live_session)

veadk_python-0.2.33/veadk/realtime/doubao_realtime_voice_llm_connection.py

@@ -0,0 +1,50 @@
+# 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
+
+from typing import Union
+
+from google.adk.models.gemini_llm_connection import GeminiLlmConnection
+from google.genai import types
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+RealtimeInput = Union[types.Blob, types.ActivityStart, types.ActivityEnd]
+
+
+class DoubaoRealtimeVoiceLlmConnection(GeminiLlmConnection):
+    """The doubao realtime voice model connection."""
+
+    async def send_realtime(self, input: RealtimeInput):
+        """Sends a chunk of audio or a frame of video to the model in realtime.
+
+        Args:
+          input: The input to send to the model.
+        """
+        if isinstance(input, types.Blob):
+            # The blob is binary and is very large. So let's not log it.
+            # logger.debug('Sending LLM Blob.')
+            # bugfix: 'error': 'decode ws request failed: unsupported protocol version 7'
+            await self._gemini_session.send_realtime_input(media=input)
+
+        elif isinstance(input, types.ActivityStart):
+            logger.debug("Sending LLM activity start signal.")
+            await self._gemini_session.send_realtime_input(activity_start=input)
+        elif isinstance(input, types.ActivityEnd):
+            logger.debug("Sending LLM activity end signal.")
+            await self._gemini_session.send_realtime_input(activity_end=input)
+        else:
+            raise ValueError("Unsupported input type: %s" % type(input))