agentscope-runtime 0.1.3__py3-none-any.whl → 0.1.5b1__py3-none-any.whl

agentscope_runtime/engine/schemas/realtime.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+import os
+import uuid
+from enum import Enum
+from typing import Optional, List, Union, Any
+
+from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
+from pydantic import BaseModel, model_validator, Field
+
+
+class AsrVendor(str, Enum):
+    MODELSTUDIO = "modelstudio"
+    AZURE = "azure"
+
+
+class TtsVendor(str, Enum):
+    MODELSTUDIO = "modelstudio"
+    AZURE = "azure"
+
+
+class ModelstudioConnection(BaseModel):
+    base_url: Optional[str] = None
+    api_key: Optional[str] = None
+    workspace_id: Optional[str] = None
+    user_agent: Optional[str] = None
+    data_inspection: Optional[str] = None
+
+
+class TtsConfig(BaseModel):
+    model: Optional[str] = None
+    voice: Optional[str] = None
+    sample_rate: Optional[int] = None
+    format: Optional[str] = None
+    bits_per_sample: Optional[int] = None
+    nb_channels: Optional[int] = None
+    chat_id: Optional[str] = None
+
+
+class ModelstudioTtsConfig(TtsConfig, ModelstudioConnection):
+    model: str = "cosyvoice-v2"
+    voice: str = os.getenv("TTS_VOICE", "longcheng_v2")
+    sample_rate: int = 16000
+    format: Optional[str] = "pcm"
+
+
+class AsrConfig(BaseModel):
+    model: Optional[str] = None
+    language: Optional[str] = None
+    sample_rate: Optional[int] = None
+    format: Optional[str] = None
+    bits_per_sample: Optional[int] = None
+    nb_channels: Optional[int] = None
+    initial_silence_timeout: Optional[int] = None
+    max_end_silence: Optional[int] = None
+    fast_vad_min_duration: Optional[int] = None
+    fast_vad_max_duration: Optional[int] = None
+
+
+class ModelstudioAsrConfig(AsrConfig, ModelstudioConnection):
+    model: Optional[str] = "gummy-realtime-v1"
+    sample_rate: Optional[int] = 16000
+    format: Optional[str] = "pcm"
+    max_end_silence: Optional[int] = 700
+    fast_vad_min_duration: Optional[int] = 200
+    fast_vad_max_duration: Optional[int] = 1100
+
+
+class ModelstudioKnowledgeBaseConfig(BaseModel):
+    index_ids: List[str]
+    workspace_id: str
+    api_key: str
+
+
+class ModelstudioVoiceChatUpstream(BaseModel):
+    dialog_mode: Optional[str] = "duplex"
+    enable_server_vad: Optional[bool] = True
+    modalities: Optional[List[str]] = Field(default_factory=lambda: ["audio"])
+    asr_vendor: Optional[AsrVendor] = AsrVendor(
+        os.getenv("ASR_VENDOR", AsrVendor.MODELSTUDIO.value),
+    )
+    asr_options: Optional[AsrConfig] = AsrConfig()
+
+
+class ModelstudioVoiceChatDownstream(BaseModel):
+    modalities: Optional[List[str]] = Field(
+        default_factory=lambda: ["audio", "text"],
+    )
+    tts_vendor: Optional[TtsVendor] = TtsVendor(
+        os.getenv("TTS_VENDOR", TtsVendor.MODELSTUDIO.value),
+    )
+    tts_options: Optional[TtsConfig] = TtsConfig()
+
+
+class ModelstudioVoiceChatParameters(BaseModel):
+    modelstudio_kb: Optional[ModelstudioKnowledgeBaseConfig] = None
+    enable_tool_call: Optional[bool] = False
+
+
+class ModelstudioVoiceChatInput(BaseModel):
+    dialog_id: Optional[str] = None
+    app_id: Optional[str] = None
+    text: Optional[str] = None
+
+
+class ModelstudioVoiceChatDirective(str, Enum):
+    SESSION_START = "SessionStart"
+    SESSION_STOP = "SessionStop"
+
+
+class ModelstudioVoiceChatEvent(str, Enum):
+    SESSION_STARTED = "SessionStarted"
+    SESSION_STOPPED = "SessionStopped"
+    AUDIO_TRANSCRIPT = "AudioTranscript"
+    RESPONSE_TEXT = "ResponseText"
+    RESPONSE_AUDIO_STARTED = "ResponseAudioStarted"
+    RESPONSE_AUDIO_ENDED = "ResponseAudioEnded"
+
+
+class ModelstudioVoiceChatInPayload(BaseModel):
+    pass
+
+
+class ModelstudioVoiceChatSessionStartPayload(ModelstudioVoiceChatInPayload):
+    session_id: Optional[str] = Field(
+        default_factory=lambda: str(uuid.uuid4()),
+    )
+    upstream: Optional[
+        ModelstudioVoiceChatUpstream
+    ] = ModelstudioVoiceChatUpstream()
+    downstream: Optional[
+        ModelstudioVoiceChatDownstream
+    ] = ModelstudioVoiceChatDownstream()
+    parameters: Optional[
+        ModelstudioVoiceChatParameters
+    ] = ModelstudioVoiceChatParameters()
+
+
+class ModelstudioVoiceChatSessionStopPayload(ModelstudioVoiceChatInPayload):
+    pass
+
+
+class ModelstudioVoiceChatRequest(BaseModel):
+    directive: ModelstudioVoiceChatDirective
+    payload: Union[
+        ModelstudioVoiceChatSessionStartPayload,
+        ModelstudioVoiceChatSessionStopPayload,
+    ]
+
+    @model_validator(mode="wrap")
+    def parse_payload_based_on_directive(
+        self,
+        values: Any,
+        handler: Any,
+    ) -> None:
+        data = values if isinstance(values, dict) else values.model_dump()
+
+        directive = data.get("directive")
+        payload_data = data.get("payload", {})
+
+        if directive == ModelstudioVoiceChatDirective.SESSION_START:
+            data["payload"] = ModelstudioVoiceChatSessionStartPayload(
+                **payload_data,
+            )
+        elif directive == ModelstudioVoiceChatDirective.SESSION_STOP:
+            data["payload"] = ModelstudioVoiceChatSessionStopPayload(
+                **payload_data,
+            )
+        else:
+            raise ValueError(f"Unsupported directive: {directive}")
+
+        return handler(data)
+
+
+class ModelstudioVoiceChatOutPayload(BaseModel):
+    session_id: Optional[str] = None
+
+
+class ModelstudioVoiceChatSessionStartedPayload(
+    ModelstudioVoiceChatOutPayload,
+):
+    pass
+
+
+class ModelstudioVoiceChatSessionStoppedPayload(
+    ModelstudioVoiceChatOutPayload,
+):
+    pass
+
+
+class ModelstudioVoiceChatAudioTranscriptPayload(
+    ModelstudioVoiceChatOutPayload,
+):
+    text: Optional[str] = ""
+    finished: bool
+
+
+class ModelstudioVoiceChatResponseTextPayload(
+    ModelstudioVoiceChatOutPayload,
+):
+    text: Optional[str] = ""
+    tool_calls: Optional[List[ChoiceDeltaToolCall]] = Field(
+        default_factory=list,
+    )
+    finished: bool
+
+
+class ModelstudioVoiceChatResponseAudioStartedPayload(
+    ModelstudioVoiceChatOutPayload,
+):
+    pass
+
+
+class ModelstudioVoiceChatResponseAudioStoppedPayload(
+    ModelstudioVoiceChatOutPayload,
+):
+    pass
+
+
+class ModelstudioVoiceChatResponse(BaseModel):
+    event: Optional[ModelstudioVoiceChatEvent]
+    payload: Union[
+        ModelstudioVoiceChatSessionStartedPayload,
+        ModelstudioVoiceChatSessionStoppedPayload,
+        ModelstudioVoiceChatAudioTranscriptPayload,
+        ModelstudioVoiceChatResponseTextPayload,
+        ModelstudioVoiceChatResponseAudioStartedPayload,
+        ModelstudioVoiceChatResponseAudioStoppedPayload,
+    ]
+
+
+class AzureConnection(BaseModel):
+    key: Optional[str] = None
+    region: Optional[str] = None
+
+
+class AzureAsrConfig(AsrConfig, AzureConnection):
+    sample_rate: Optional[int] = 16000
+    format: Optional[str] = "pcm"
+    bits_per_sample: Optional[int] = 16
+    nb_channels: Optional[int] = 1
+    initial_silence_timeout: Optional[int] = 5000
+    max_end_silence: Optional[int] = 800
+    language: Optional[str] = os.getenv("ASR_LANG", "en-US")
+
+
+class AzureTtsConfig(TtsConfig, AzureConnection):
+    voice: Optional[str] = os.getenv(
+        "TTS_VOICE",
+        "en-US-AvaMultilingualNeural",
+    )
+    sample_rate: Optional[int] = 16000
+    format: Optional[str] = "pcm"
+    bits_per_sample: Optional[int] = 16
+    nb_channels: Optional[int] = 1

agentscope_runtime/engine/services/context_manager.py

@@ -151,11 +151,13 @@ async def create_context_manager(
     memory_service: MemoryService = None,
     session_history_service: SessionHistoryService = None,
     rag_service: RAGService = None,
+    context_composer_cls=ContextComposer,
 ):
     manager = ContextManager(
         memory_service=memory_service,
         session_history_service=session_history_service,
         rag_service=rag_service,
+        context_composer_cls=context_composer_cls,
     )
 
     async with manager:

agentscope_runtime/engine/services/mem0_memory_service.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Optional, Dict, Any, List
+from .memory_service import MemoryService
+from ..schemas.agent_schemas import Message, MessageType, ContentType
+
+
+class Mem0MemoryService(MemoryService):
+    """
+    Memory service that uses mem0 to store and retrieve memories.
+    To get the api key, please refer to the following link:
+    https://docs.mem0.ai/platform/quickstart
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        from mem0 import AsyncMemoryClient
+
+        mem0_api_key = os.getenv("MEM0_API_KEY")
+        if mem0_api_key is None:
+            raise ValueError("MEM0_API_KEY is not set")
+        mem0_api_key = os.getenv("MEM0_API_KEY")
+
+        # get the mem0 client instance
+        self.service = AsyncMemoryClient(api_key=mem0_api_key)
+
+    @staticmethod
+    async def get_query_text(message: Message) -> str:
+        """
+        Get the query text from the message.
+        """
+        if message:
+            if message.type == MessageType.MESSAGE:
+                for content in message.content:
+                    if content.type == ContentType.TEXT:
+                        return content.text
+        return ""
+
+    @staticmethod
+    def transform_message(message: Message) -> dict:
+        content_text = None
+
+        try:
+            if hasattr(message, "content") and isinstance(
+                message.content,
+                list,
+            ):
+                if len(message.content) > 0 and hasattr(
+                    message.content[0],
+                    "text",
+                ):
+                    content_text = message.content[0].text
+        except (AttributeError, IndexError):
+            # Log error or handle appropriately
+            pass
+
+        return {
+            "role": getattr(message, "role", None),
+            "content": content_text,
+        }
+
+    async def transform_messages(self, messages: List[Message]) -> List[dict]:
+        return [self.transform_message(message) for message in messages]
+
+    async def start(self):
+        pass
+
+    async def stop(self):
+        pass
+
+    async def health(self):
+        pass
+
+    async def add_memory(
+        self,
+        user_id: str,
+        messages: list,
+        session_id: Optional[str] = None,
+    ):
+        messages = await self.transform_messages(messages)
+        return await self.service.add(
+            messages=messages,
+            user_id=user_id,
+            run_id=session_id,
+            # async_mode=True,
+        )
+
+    async def search_memory(
+        self,
+        user_id: str,
+        messages: list,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        query = await self.get_query_text(messages[-1])
+        kwargs = {
+            "query": query,
+            "user_id": user_id,
+        }
+        if filters:
+            kwargs["filters"] = filters
+        return await self.service.search(**kwargs)
+
+    async def list_memory(
+        self,
+        user_id: str,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        kwargs = {"user_id": user_id}
+        if filters:
+            kwargs["filters"] = filters
+        return await self.service.get_all(**kwargs)
+
+    async def delete_memory(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> None:
+        if session_id:
+            return await self.service.delete_all(
+                user_id=user_id,
+                run_id=session_id,
+            )
+        else:
+            return await self.service.delete_all(user_id=user_id)

agentscope_runtime/engine/services/memory_service.py

@@ -137,7 +137,8 @@ class InMemoryMemoryService(MemoryService):
         if storage_key not in self._store[user_id]:
             self._store[user_id][storage_key] = []
 
-        self._store[user_id][storage_key].extend(messages)
+        if messages:
+            self._store[user_id][storage_key].extend(messages)
 
     async def search_memory(
         self,

agentscope_runtime/engine/services/redis_session_history_service.py

@@ -112,9 +112,10 @@ class RedisSessionHistoryService(SessionHistoryService):
             message = [message]
         norm_message = []
         for msg in message:
-            if not isinstance(msg, Message):
-                msg = Message.model_validate(msg)
-            norm_message.append(msg)
+            if msg is not None:
+                if not isinstance(msg, Message):
+                    msg = Message.model_validate(msg)
+                norm_message.append(msg)
 
         session.messages.extend(norm_message)
 

agentscope_runtime/engine/services/session_history_service.py

@@ -238,9 +238,10 @@ class InMemorySessionHistoryService(SessionHistoryService):
 
         norm_message = []
         for msg in message:
-            if not isinstance(msg, Message):
-                msg = Message.model_validate(msg)
-            norm_message.append(msg)
+            if msg is not None:
+                if not isinstance(msg, Message):
+                    msg = Message.model_validate(msg)
+                norm_message.append(msg)
         session.messages.extend(norm_message)
 
         # update the in memory copy