agentscope-runtime 0.2.0b1__py3-none-any.whl → 1.0.0__py3-none-any.whl

agentscope_runtime/engine/services/environment_manager.py

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import List
-from contextlib import asynccontextmanager
-
-from .manager import ServiceManager
-from .sandbox_service import SandboxService
-
-
-class EnvironmentManager(ServiceManager):
-    """
-    The EnvironmentManager class for managing environment-related services.
-    """
-
-    def __init__(self, sandbox_service: SandboxService = None):
-        self._sandbox_service = sandbox_service
-        super().__init__()
-
-    def _register_default_services(self):
-        """Register default services for environment management."""
-        self._sandbox_service = self._sandbox_service or SandboxService()
-        self.register_service("sandbox", self._sandbox_service)
-
-    def connect_sandbox(
-        self,
-        session_id,
-        user_id,
-        env_types=None,
-        tools=None,
-    ) -> List:
-        return self._sandbox_service.connect(
-            session_id,
-            user_id,
-            env_types=env_types,
-            tools=tools,
-        )
-
-    def release_sandbox(self, session_id, user_id):
-        return self._sandbox_service.release(session_id, user_id)
-
-
-@asynccontextmanager
-async def create_environment_manager(
-    sandbox_service: SandboxService = None,
-):
-    manager = EnvironmentManager(
-        sandbox_service=sandbox_service,
-    )
-
-    async with manager:
-        yield manager

agentscope_runtime/engine/services/manager.py

@@ -1,174 +0,0 @@
-# -*- coding: utf-8 -*-
-import logging
-from contextlib import AsyncExitStack
-from typing import Dict, Any, Type, List
-from abc import ABC, abstractmethod
-
-from agentscope_runtime.engine import Service
-
-logger = logging.getLogger(__name__)
-
-
-class ServiceManager(ABC):
-    """
-    Abstract base class for service managers.
-    Provides common functionality for service registration and lifecycle
-    management.
-    """
-
-    def __init__(self):
-        self.services = []
-        self.service_instances = {}
-        self._exit_stack = AsyncExitStack()
-
-        # Initialize default services
-        self._register_default_services()
-
-    @abstractmethod
-    def _register_default_services(self):
-        """
-        Register default services for this manager. Override in
-        subclasses.
-        """
-
-    def register(self, service_class: Type, *args, name: str = None, **kwargs):
-        """
-        Register a service.
-
-        Args:
-            service_class: The class of the service to register.
-            *args: Positional arguments for service initialization.
-            name: Optional service name. Defaults to class name without
-                'Service' suffix and converted to lowercase.
-            **kwargs: Keyword arguments for service initialization.
-
-        Returns:
-            self: For method chaining
-        """
-        if name is None:
-            name = service_class.__name__.replace("Service", "").lower()
-
-        # Check if service name already exists
-        if any(service[3] == name for service in self.services):
-            raise ValueError(
-                f"Service with name '{name}' is already registered",
-            )
-
-        self.services.append((service_class, args, kwargs, name))
-        logger.debug(f"Registered service: {name} ({service_class.__name__})")
-        return self
-
-    def register_service(self, name: str, service: Service):
-        """Register an already instantiated service.
-
-        Args:
-            name: Service name
-            service: Service instance
-
-        Returns:
-            self: For method chaining
-        """
-        if name in self.service_instances:
-            raise ValueError(
-                f"Service with name '{name}' is already registered",
-            )
-
-        self.service_instances[name] = service
-        logger.debug(f"Registered service instance: {name}")
-        return self
-
-    async def __aenter__(self):
-        """Start all registered services using AsyncExitStack."""
-        try:
-            # Track services that were registered with register() to avoid
-            # duplicate processing
-            registered_names = set()
-
-            # Start services that were registered with register()
-            for service_class, args, kwargs, name in self.services:
-                logger.debug(f"Starting service: {name}")
-                instance = service_class(*args, **kwargs)
-
-                # Use AsyncExitStack to manage the context
-                await self._exit_stack.enter_async_context(instance)
-                self.service_instances[name] = instance
-                registered_names.add(name)  # Track this service as processed
-                logger.debug(f"Successfully started service: {name}")
-
-            # Start services that were registered with register_service()
-            # These services are already instantiated, just need to enter
-            # their context
-            for name, service in list(self.service_instances.items()):
-                if (
-                    name not in registered_names
-                ):  # Only process services not from register() method
-                    logger.debug(f"Starting pre-instantiated service: {name}")
-                    await self._exit_stack.enter_async_context(service)
-                    logger.debug(
-                        f"Successfully started pre-instantiated service:"
-                        f" {name}",
-                    )
-
-            return self
-
-        except Exception as e:
-            logger.error(f"Failed to start services: {e}")
-            # Ensure proper cleanup if initialization fails
-            await self._exit_stack.aclose()
-            raise
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Close all services using AsyncExitStack."""
-        logger.debug("Stopping all services")
-        await self._exit_stack.aclose()
-        self.service_instances.clear()
-        logger.debug("All services stopped")
-        return False
-
-    def __getattr__(self, name: str):
-        """
-        Enable attribute access for services, e.g., manager.env,
-        manager.session.
-        """
-        if name in self.service_instances:
-            return self.service_instances[name]
-        raise AttributeError(f"Service '{name}' not found")
-
-    def __getitem__(self, name: str):
-        """Enable dictionary-style access for services."""
-        if name in self.service_instances:
-            return self.service_instances[name]
-        raise KeyError(f"Service '{name}' not found")
-
-    def get(self, name: str, default=None):
-        """Explicitly retrieve a service instance with optional default."""
-        return self.service_instances.get(name, default)
-
-    def has_service(self, name: str) -> bool:
-        """Check if a service exists."""
-        return name in self.service_instances
-
-    def list_services(self) -> List[str]:
-        """List all registered service names."""
-        return list(self.service_instances.keys())
-
-    @property
-    def all_services(self) -> Dict[str, Any]:
-        """Retrieve all service instances."""
-        return self.service_instances.copy()
-
-    async def health_check(self) -> Dict[str, bool]:
-        """Check health of all services."""
-        health_status = {}
-        for name, service in self.service_instances.items():
-            try:
-                if hasattr(service, "health"):
-                    health_status[name] = await service.health()
-                else:
-                    health_status[
-                        name
-                    ] = True  # Assume healthy if no health method
-            except Exception as e:
-                logger.error(f"Health check failed for service {name}: {e}")
-                health_status[name] = False
-        return health_status

agentscope_runtime/engine/services/rag_service.py

@@ -1,195 +0,0 @@
-# -*- coding: utf-8 -*-
-from .base import ServiceWithLifecycleManager
-from ..schemas.agent_schemas import Message, MessageType
-
-
-class RAGService(ServiceWithLifecycleManager):
-    """
-    RAG Service
-    """
-
-    async def get_query_text(self, message: Message) -> str:
-        """
-        Gets the query text from the messages.
-
-        Args:
-            message: A list of messages.
-
-        Returns:
-            The query text.
-        """
-        if message:
-            if message.type == MessageType.MESSAGE:
-                for content in message.content:
-                    if content.type == "text":
-                        return content.text
-        return ""
-
-    async def retrieve(self, query: str, k: int = 1) -> list[str]:
-        """
-        Retrieves similar documents based on the given query.
-
-        Args:
-            query (str): The query string to search for similar documents.
-            k (int, optional): The number of similar documents to retrieve.
-            Defaults to 1.
-
-        Returns:
-            list[str]: A list of document contents that are similar to
-            the query.
-        """
-        raise NotImplementedError
-
-    async def start(self) -> None:
-        """Starts the service."""
-
-    async def stop(self) -> None:
-        """Stops the service."""
-
-    async def health(self) -> bool:
-        """Checks the health of the service."""
-        return True
-
-
-DEFAULT_URI = "milvus_demo.db"
-
-
-class LangChainRAGService(RAGService):
-    """
-    RAG Service using LangChain
-    """
-
-    def __init__(
-        self,
-        vectorstore=None,
-        embedding=None,
-    ):
-        # set default embedding alg.
-        if embedding is None:
-            from langchain_community.embeddings import DashScopeEmbeddings
-
-            self.embeddings = DashScopeEmbeddings()
-        else:
-            self.embeddings = embedding
-
-        # set default vectorstore class.
-        if vectorstore is None:
-            from langchain_milvus import Milvus
-
-            self.vectorstore = Milvus.from_documents(
-                [],
-                embedding=self.embeddings,
-                connection_args={
-                    "uri": DEFAULT_URI,
-                },
-                drop_old=False,
-            )
-        else:
-            self.vectorstore = vectorstore
-
-    async def retrieve(self, query: str, k: int = 1) -> list[str]:
-        """
-        Retrieves similar documents based on the given query using LangChain.
-
-        Args:
-            query (str): The query string to search for similar documents.
-            k (int, optional): The number of similar documents to retrieve.
-            Defaults to 1.
-
-        Returns:
-            list[str]: A list of document contents that are similar to the
-            query.
-
-        Raises:
-            ValueError: If the vector store is not initialized.
-        """
-        if self.vectorstore is None:
-            raise ValueError(
-                "Vector store not initialized. Call build_index first.",
-            )
-        docs = self.vectorstore.similarity_search(query, k=k)
-        return [doc.page_content for doc in docs]
-
-    async def start(self) -> None:
-        """Starts the service."""
-
-    async def stop(self) -> None:
-        """Stops the service."""
-
-    async def health(self) -> bool:
-        """Checks the health of the service."""
-        return True
-
-
-class LlamaIndexRAGService(RAGService):
-    """
-    RAG Service using LlamaIndex
-    """
-
-    def __init__(
-        self,
-        vectorstore=None,
-        embedding=None,
-    ):
-        # set default embedding alg.
-        if embedding is None:
-            from langchain_community.embeddings import DashScopeEmbeddings
-
-            self.embeddings = DashScopeEmbeddings()
-        else:
-            self.embeddings = embedding
-
-        # set default vectorstore.
-        if vectorstore is None:
-            from llama_index.core import VectorStoreIndex
-            from llama_index.core.schema import Document
-            from llama_index.vector_stores.milvus import MilvusVectorStore
-
-            # Create empty documents list for initialization
-            documents = [Document(text="")]
-
-            # Initialize Milvus vector store
-            self.vector_store = MilvusVectorStore(
-                uri=DEFAULT_URI,
-                overwrite=False,
-            )
-
-            # Create index
-            self.index = VectorStoreIndex.from_documents(
-                documents=documents,
-                embed_model=self.embeddings,
-                vector_store=self.vector_store,
-            )
-        else:
-            self.index = vectorstore
-
-    async def retrieve(self, query: str, k: int = 1) -> list[str]:
-        """
-        Retrieves similar documents based on the given query using LlamaIndex.
-
-        Args:
-            query (str): The query string to search for similar documents.
-            k (int, optional): The number of similar documents to retrieve.
-            Defaults to 1.
-
-        Returns:
-            list[str]: A list of document contents that are similar to the
-            query.
-
-        Raises:
-            ValueError: If the index is not initialized.
-        """
-        if self.index is None:
-            raise ValueError(
-                "Index not initialized.",
-            )
-
-        # Create query engine and query
-        query_engine = self.index.as_retriever(similarity_top_k=k)
-        response = query_engine.retrieve(query)
-
-        # Extract text from nodes
-        if len(response) > 0:
-            return [node.node.get_content() for node in response]
-        else:
-            return [""]

agentscope_runtime/engine/services/tablestore_rag_service.py

@@ -1,143 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint: disable=redefined-outer-name
-import asyncio
-import uuid
-from typing import Any, List, Optional, Union
-
-try:
-    from langchain_community.embeddings import DashScopeEmbeddings
-    from langchain_core.documents import Document
-    from langchain_core.embeddings import Embeddings
-    from tablestore import AsyncOTSClient as AsyncTablestoreClient
-    from tablestore import VectorMetricType
-    from tablestore_for_agent_memory.base.base_knowledge_store import (
-        Document as TablestoreDocument,
-    )
-    from tablestore_for_agent_memory.knowledge.async_knowledge_store import (
-        AsyncKnowledgeStore,
-    )
-except ImportError as e:
-    raise ImportError(
-        "aliyun_tablestore is not available. "
-        "Please run pip install agentscope-runtime[aliyun_tablestore_ext]",
-    ) from e
-
-from .rag_service import RAGService
-from .utils.tablestore_service_utils import tablestore_log
-
-
-class TablestoreRAGService(RAGService):
-    """
-    RAG Service using Tablestore(aliyun tablestore)
-    based on tablestore_for_agent_memory
-    (https://github.com/aliyun/
-    alibabacloud-tablestore-for-agent-memory/blob/main/python/docs/knowledge_store_tutorial.ipynb).
-    """
-
-    _SEARCH_INDEX_NAME = "agentscope_runtime_knowledge_search_index_name"
-    _DEFAULT_SESSION_ID = "default"
-
-    def __init__(
-        self,
-        tablestore_client: AsyncTablestoreClient,
-        embedding_model: Optional[Embeddings] = None,
-        vector_dimension: int = 1536,
-        table_name: Optional[str] = "agentscope_runtime_rag",
-        text_field: Optional[str] = "text",
-        embedding_field: Optional[str] = "embedding",
-        vector_metric_type: VectorMetricType = VectorMetricType.VM_COSINE,
-        **kwargs: Any,
-    ):
-        self._embedding_model = (
-            embedding_model if embedding_model else DashScopeEmbeddings()
-        )
-
-        self._tablestore_client = tablestore_client
-        self._vector_dimension = vector_dimension
-        self._table_name = table_name
-        self._text_field = text_field
-        self._embedding_field = embedding_field
-        self._vector_metric_type = vector_metric_type
-        self._knowledge_store: Optional[AsyncKnowledgeStore] = None
-        self._knowledge_store_init_parameter_kwargs = kwargs
-
-    async def _init_knowledge_store(self) -> None:
-        self._knowledge_store = AsyncKnowledgeStore(
-            tablestore_client=self._tablestore_client,
-            vector_dimension=self._vector_dimension,
-            enable_multi_tenant=False,
-            table_name=self._table_name,
-            search_index_name=TablestoreRAGService._SEARCH_INDEX_NAME,
-            text_field=self._text_field,
-            embedding_field=self._embedding_field,
-            vector_metric_type=self._vector_metric_type,
-            **self._knowledge_store_init_parameter_kwargs,
-        )
-
-        await self._knowledge_store.init_table()
-
-    async def start(self) -> None:
-        """Start the tablestore service"""
-        if self._knowledge_store:
-            return
-        await self._init_knowledge_store()
-
-    async def stop(self) -> None:
-        """Close the tablestore service"""
-        if self._knowledge_store is None:
-            return
-        knowledge_store = self._knowledge_store
-        self._knowledge_store = None
-        await knowledge_store.close()
-
-    async def health(self) -> bool:
-        """Checks the health of the service."""
-        if self._knowledge_store is None:
-            tablestore_log("Tablestore rag service is not started.")
-            return False
-
-        try:
-            async for _ in await self._knowledge_store.get_all_documents():
-                return True
-            return True
-        except Exception as e:
-            tablestore_log(
-                f"Tablestore rag service "
-                f"cannot access Tablestore, error: {str(e)}.",
-            )
-            return False
-
-    async def add_docs(self, docs: Union[Document, List[Document]]):
-        if not isinstance(docs, List):
-            docs = [docs]
-
-        contents = [doc.page_content for doc in docs]
-        # Encode in batches to reduce time consumption.
-        embeddings = self._embedding_model.embed_documents(contents)
-
-        put_tasks = [
-            # The conversion logic here is simple,
-            # so no separate conversion function is defined.
-            self._knowledge_store.put_document(
-                document=TablestoreDocument(
-                    document_id=f"document_{uuid.uuid4()}",
-                    text=doc.page_content,
-                    embedding=embedding,
-                    metadata=doc.metadata,
-                ),
-            )
-            for doc, embedding in zip(docs, embeddings)
-        ]
-        await asyncio.gather(*put_tasks)
-
-    async def retrieve(self, query: str, k: int = 1) -> list[str]:
-        matched_text = [
-            hit.document.text
-            for hit in (
-                await self._knowledge_store.vector_search(
-                    query_vector=self._embedding_model.embed_query(query),
-                    top_k=k,
-                )
-            ).hits
-        ]
-        return matched_text

agentscope_runtime/sandbox/tools/__init__.py

@@ -1,12 +0,0 @@
-# -*- coding: utf-8 -*-
-from .sandbox_tool import SandboxTool
-from .mcp_tool import MCPTool
-from .function_tool import FunctionTool, function_tool, create_function_tool
-
-__all__ = [
-    "SandboxTool",
-    "MCPTool",
-    "FunctionTool",
-    "function_tool",
-    "create_function_tool",
-]

agentscope_runtime/sandbox/tools/base/__init__.py

@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -*-
-from .tool import run_shell_command, run_ipython_cell
-
-
-__all__ = [
-    "run_shell_command",
-    "run_ipython_cell",
-]

agentscope_runtime/sandbox/tools/base/tool.py

@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import Dict
-
-from ..sandbox_tool import SandboxTool
-
-
-class RunIPythonCellTool(SandboxTool):
-    """Tool for running IPython cells."""
-
-    _name: str = "run_ipython_cell"
-    _sandbox_type: str = "base"
-    _tool_type: str = "generic"
-    _schema: Dict = {
-        "name": "run_ipython_cell",
-        "description": "Run an IPython cell.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "code": {
-                    "type": "string",
-                    "description": "IPython code to execute",
-                },
-            },
-            "required": ["code"],
-        },
-    }
-
-
-class RunShellCommandTool(SandboxTool):
-    """Tool for running shell commands."""
-
-    _name: str = "run_shell_command"
-    _sandbox_type: str = "base"
-    _tool_type: str = "generic"
-    _schema: Dict = {
-        "name": "run_shell_command",
-        "description": "Run a shell command.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "command": {
-                    "type": "string",
-                    "description": "Shell command to execute",
-                },
-            },
-            "required": ["command"],
-        },
-    }
-
-
-run_ipython_cell = RunIPythonCellTool()
-run_shell_command = RunShellCommandTool()

agentscope_runtime/sandbox/tools/browser/__init__.py

@@ -1,57 +0,0 @@
-# -*- coding: utf-8 -*-
-from .tool import (
-    run_shell_command,
-    run_ipython_cell,
-    browser_close,
-    browser_resize,
-    browser_console_messages,
-    browser_handle_dialog,
-    browser_file_upload,
-    browser_press_key,
-    browser_navigate,
-    browser_navigate_back,
-    browser_navigate_forward,
-    browser_network_requests,
-    browser_pdf_save,
-    browser_take_screenshot,
-    browser_snapshot,
-    browser_click,
-    browser_drag,
-    browser_hover,
-    browser_type,
-    browser_select_option,
-    browser_tab_list,
-    browser_tab_new,
-    browser_tab_select,
-    browser_tab_close,
-    browser_wait_for,
-)
-
-
-__all__ = [
-    "run_shell_command",
-    "run_ipython_cell",
-    "browser_close",
-    "browser_resize",
-    "browser_console_messages",
-    "browser_handle_dialog",
-    "browser_file_upload",
-    "browser_press_key",
-    "browser_navigate",
-    "browser_navigate_back",
-    "browser_navigate_forward",
-    "browser_network_requests",
-    "browser_pdf_save",
-    "browser_take_screenshot",
-    "browser_snapshot",
-    "browser_click",
-    "browser_drag",
-    "browser_hover",
-    "browser_type",
-    "browser_select_option",
-    "browser_tab_list",
-    "browser_tab_new",
-    "browser_tab_select",
-    "browser_tab_close",
-    "browser_wait_for",
-]