agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/engine/llms/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+from .base_llm import BaseLLM
+from .qwen_llm import QwenLLM

agentscope_runtime/engine/llms/base_llm.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+from typing import AsyncGenerator
+
+
+class BaseLLM:
+    base_url = None
+
+    def __init__(self, model_name: str, **kwargs):
+        self.client = None
+        self.async_client = None
+        self.model_name = model_name
+        self.kwargs = kwargs
+
+    def generate(self, prompt: str, **kwargs) -> str:
+        """
+        Generate a response from the Qwen LLM model.
+
+        Args:
+            prompt (str): The prompt to generate a response for.
+            **kwargs: Additional keyword arguments to pass to the model.
+
+        Returns:
+            str: The generated response.
+        """
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt},
+            ],
+            **kwargs,
+        )
+        return response.choices[0].message.content
+
+    def chat(self, messages, **kwargs) -> str:
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            **kwargs,
+        )
+        return response.choices[0].message.content
+
+    async def chat_stream(
+        self,
+        messages,
+        tools=None,
+        **kwargs,
+    ) -> AsyncGenerator[str, None]:
+        # call model
+        # TODO: use async client
+        generator = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages,
+            tools=tools,
+            stream=True,
+            **kwargs,
+        )
+
+        for chunk in generator:
+            yield chunk

agentscope_runtime/engine/llms/qwen_llm.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+import os
+
+from openai import Client, AsyncClient
+
+from .base_llm import BaseLLM
+
+
+class QwenLLM(BaseLLM):
+    """
+    QwenLLM is a class that provides a wrapper around the Qwen LLM model.
+    """
+
+    base_url = None
+
+    def __init__(
+        self,
+        model_name: str = "qwen-turbo",
+        api_key: str = None,
+        **kwargs,
+    ):
+        """
+        Initialize the QwenLLM class.
+
+        Args:
+            model_name (str): The name of the Qwen LLM model to use.
+                Defaults to "qwen-turbo".
+            api_key (str): The API key for Qwen service.
+                If None, will read from DASHSCOPE_API_KEY environment variable.
+        """
+        super().__init__(model_name, **kwargs)
+
+        if api_key is None:
+            api_key = os.getenv("DASHSCOPE_API_KEY")
+        if self.base_url is None:
+            default_base_url = (
+                "https://dashscope.aliyuncs.com/compatible-mode/v1"
+            )
+            self.base_url = os.getenv("DASHSCOPE_BASE_URL", default_base_url)
+        self.client = Client(
+            api_key=api_key,
+            base_url=self.base_url,
+        )
+        self.async_client = AsyncClient(
+            api_key=api_key,
+            base_url=self.base_url,
+        )

agentscope_runtime/engine/runner.py

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+import uuid
+from typing import Optional, List, AsyncGenerator, Any
+
+from openai.types.chat import ChatCompletion
+
+from .deployers.adapter.protocol_adapter import ProtocolAdapter
+from .agents import Agent
+from .schemas.context import Context
+from .deployers import (
+    DeployManager,
+    LocalDeployManager,
+)
+from .schemas.agent_schemas import (
+    Event,
+    AgentRequest,
+    RunStatus,
+    AgentResponse,
+)
+from .services.context_manager import ContextManager
+from .services.environment_manager import EnvironmentManager
+from .tracing import TraceType
+from .tracing.wrapper import trace
+
+
+class Runner:
+    def __init__(
+        self,
+        agent: Agent,
+        environment_manager: Optional[EnvironmentManager] = None,
+        context_manager: Optional[ContextManager] = None,
+    ) -> None:
+        """
+        Initializes a runner as core function.
+        Args:
+            agent: The agent to run.
+            environment_manager: The environment manager
+            context_manager: The context manager
+        """
+        self._agent = agent
+        self._environment_manager = environment_manager
+        self._context_manager = context_manager
+        self._deploy_managers = {}
+
+    # TODO: should be sync method?
+    async def deploy(
+        self,
+        deploy_manager: DeployManager = LocalDeployManager(),
+        endpoint_path: str = "/process",
+        stream: bool = True,
+        protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+    ):
+        """
+        Deploys the agent as a service.
+
+        Args:
+            protocol_adapters: protocol adapters
+            deploy_manager: Deployment manager to handle service deployment
+            endpoint_path: API endpoint path for the processing function
+            stream: If start a streaming service
+        Returns:
+            URL of the deployed service
+
+        Raises:
+            RuntimeError: If deployment fails
+        """
+        if stream:
+            deploy_func = self.stream_query
+        else:
+            deploy_func = self.query
+        deploy_result = await deploy_manager.deploy(
+            deploy_func,
+            endpoint_path=endpoint_path,
+            protocol_adapters=protocol_adapters,
+        )
+        self._deploy_managers[deploy_manager.deploy_id] = deploy_result
+        return deploy_result
+
+    @trace(TraceType.AGENT_STEP)
+    async def stream_query(  # pylint:disable=unused-argument
+        self,
+        request: AgentRequest,
+        user_id: Optional[str] = None,
+        tools: Optional[List] = None,
+        **kwargs: Any,
+    ) -> AsyncGenerator[Event, None]:
+        """
+        Streams the agent.
+        """
+        response = AgentResponse()
+        yield response
+
+        response.in_progress()
+        yield response
+
+        user_id = user_id or str(uuid.uuid4())
+        session_id = request.session_id or str(uuid.uuid4())
+        request_input = request.input
+        session = await self._context_manager.compose_session(
+            user_id=user_id,
+            session_id=session_id,
+        )
+
+        context = Context(
+            user_id=session.user_id,
+            session=session,
+            request=request,
+            current_messages=request_input,
+            context_manager=self._context_manager,
+            environment_manager=self._environment_manager,
+            agent=self._agent,
+        )
+
+        # TODO: Update activate tools into the context (not schema only)
+        tools = tools or getattr(self._agent, "tools", None)
+        if tools:
+            # Lazy import
+            from ..sandbox.tools.utils import setup_tools
+
+            activated_tools, schemas = setup_tools(
+                tools=tools,
+                environment_manager=context.environment_manager,
+                session_id=session.id,
+                user_id=session.user_id,
+                include_schemas=True,
+            )
+
+            # update the context
+            context.activate_tools = activated_tools
+
+            # convert schema to a function call tool lists
+            # TODO: use pydantic model
+            if hasattr(context.request, "tools") and context.request.tools:
+                context.request.tools.extend(schemas)
+
+        # update message in session
+        await context.context_manager.compose_context(
+            session=context.session,
+            request_input=request_input,
+        )
+
+        async for event in context.agent.run_async(context):
+            if (
+                event.status == RunStatus.Completed
+                and event.object == "message"
+            ):
+                response.add_new_message(event)
+            yield event
+
+        await context.context_manager.append(
+            session=context.session,
+            event_output=response.output,
+        )
+        yield response.completed()
+
+    @trace(TraceType.AGENT_STEP)
+    async def query(  # pylint:disable=unused-argument
+        self,
+        message: List[dict],
+        session_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> ChatCompletion:
+        """
+        Streams the agent.
+        """
+        return self._agent.query(message, session_id)
+
+    # TODO: should be sync method?
+    async def stop(
+        self,
+        deploy_id: str,
+    ) -> None:
+        """
+        Stops the agent service.
+
+        Args:
+            deploy_id: Optional deploy ID (not used for service shutdown)
+
+        Raises:
+            RuntimeError: If stopping fails
+        """
+        if hasattr(self, "_deploy_manager") and self._deploy_manager:
+            await self._deploy_manager[deploy_id].stop()
+        else:
+            # No deploy manager found, nothing to stop
+            pass