agentscope-runtime 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

agentscope_runtime/engine/services/reme_personal_memory_service.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Optional, Dict, Any, List
+
+from .memory_service import MemoryService
+from ..schemas.agent_schemas import Message
+
+
+class ReMePersonalMemoryService(MemoryService):
+    """
+    ReMe requires the following env variables to be set:
+    FLOW_EMBEDDING_API_KEY=sk-xxxx
+    FLOW_EMBEDDING_BASE_URL=https://xxxx/v1
+    FLOW_LLM_API_KEY=sk-xxxx
+    FLOW_LLM_BASE_URL=https://xxxx/v1
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        for key in [
+            "FLOW_EMBEDDING_API_KEY",
+            "FLOW_EMBEDDING_BASE_URL",
+            "FLOW_LLM_API_KEY",
+            "FLOW_LLM_BASE_URL",
+        ]:
+            if os.getenv(key) is None:
+                raise ValueError(f"{key} is not set")
+
+        from reme_ai.service.personal_memory_service import (
+            PersonalMemoryService,
+        )
+
+        self.service = PersonalMemoryService()
+
+    @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,
+        }
+
+    def transform_messages(self, messages: List[Message]) -> List[dict]:
+        return [self.transform_message(message) for message in messages]
+
+    async def start(self) -> None:
+        return await self.service.start()
+
+    async def stop(self) -> None:
+        return await self.service.stop()
+
+    async def health(self) -> bool:
+        return await self.service.health()
+
+    async def add_memory(
+        self,
+        user_id: str,
+        messages: list,
+        session_id: Optional[str] = None,
+    ) -> None:
+        return await self.service.add_memory(
+            user_id,
+            self.transform_messages(messages),
+            session_id,
+        )
+
+    async def search_memory(
+        self,
+        user_id: str,
+        messages: list,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        return await self.service.search_memory(
+            user_id,
+            self.transform_messages(messages),
+            filters,
+        )
+
+    async def list_memory(
+        self,
+        user_id: str,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        return await self.service.list_memory(user_id, filters)
+
+    async def delete_memory(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> None:
+        return await self.service.delete_memory(user_id, session_id)

agentscope_runtime/engine/services/reme_task_memory_service.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+from .reme_personal_memory_service import ReMePersonalMemoryService
+
+
+class ReMeTaskMemoryService(ReMePersonalMemoryService):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        from reme_ai.service.task_memory_service import TaskMemoryService
+
+        self.service = TaskMemoryService()

agentscope_runtime/sandbox/box/browser/browser_sandbox.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=too-many-public-methods
 from typing import Optional
+from urllib.parse import urlparse, urlunparse
 
 from ...constant import IMAGE_TAG
 from ...registry import SandboxRegistry
@@ -8,6 +9,23 @@ from ...enums import SandboxType
 from ...box.sandbox import Sandbox
 
 
+def http_to_ws(url, use_localhost=True):
+    parsed = urlparse(url)
+    ws_scheme = "wss" if parsed.scheme == "https" else "ws"
+
+    hostname = parsed.hostname
+    if use_localhost and hostname == "127.0.0.1":
+        hostname = "localhost"
+
+    if parsed.port:
+        new_netloc = f"{hostname}:{parsed.port}"
+    else:
+        new_netloc = hostname
+
+    ws_url = urlunparse(parsed._replace(scheme=ws_scheme, netloc=new_netloc))
+    return ws_url
+
+
 @SandboxRegistry.register(
     f"agentscope/runtime-sandbox-browser:{IMAGE_TAG}",
     sandbox_type=SandboxType.BROWSER,
@@ -31,6 +49,13 @@ class BrowserSandbox(Sandbox):
             SandboxType.BROWSER,
         )
 
+    @property
+    def browser_ws(self):
+        if self.base_url is None:
+            # Local mode
+            return self.get_info()["front_browser_ws"]
+        return http_to_ws(f"{self.base_url}/browser/{self.sandbox_id}/cast")
+
     def browser_close(self):
         return self.call_tool("browser_close", {})
 

agentscope_runtime/sandbox/box/sandbox.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
+import atexit
 import logging
+import signal
 from typing import Any, Optional
 
 from ..enums import SandboxType
@@ -26,6 +28,7 @@ class Sandbox:
         """
         Initialize the sandbox interface.
         """
+        self.base_url = base_url
         if base_url:
             self.embed_mode = False
             self.manager_api = SandboxManager(
@@ -60,17 +63,67 @@ class Sandbox:
         self.sandbox_type = sandbox_type
         self.timeout = timeout
 
+        # Clean up function enabled in embed mode
+        if self.embed_mode:
+            atexit.register(self._cleanup)
+            self._register_signal_handlers()
+
+    def _register_signal_handlers(self) -> None:
+        """
+        Register signal handlers for graceful shutdown and cleanup.
+        Handles SIGINT (Ctrl+C) and, if available, SIGTERM to ensure that
+        the sandbox is properly cleaned up when the process receives these
+        signals. On platforms where SIGTERM is not available (e.g.,
+        Windows), only SIGINT is handled.
+        """
+
+        def _handler(signum, frame):  # pylint: disable=unused-argument
+            logger.debug(
+                f"Received signal {signum}, stopping Sandbox"
+                f" {self.sandbox_id}...",
+            )
+            self._cleanup()
+            raise SystemExit(0)
+
+        # Windows does not support SIGTERM
+        if hasattr(signal, "SIGTERM"):
+            signals = [signal.SIGINT, signal.SIGTERM]
+        else:
+            signals = [signal.SIGINT]
+
+        for sig in signals:
+            try:
+                signal.signal(sig, _handler)
+            except Exception as e:
+                logger.warning(f"Cannot register handler for {sig}: {e}")
+
+    def _cleanup(self):
+        """
+        Clean up resources associated with the sandbox.
+        This method is called when the sandbox receives termination signals
+        (such as SIGINT or SIGTERM) in embed mode, or when exiting a context
+        manager block. In embed mode, it calls the manager API's __exit__
+        method to clean up all resources. Otherwise, it releases the
+        specific sandbox instance.
+        """
+        try:
+            # Remote not need to close the embed_manager
+            if self.embed_mode:
+                # Clean all
+                self.manager_api.__exit__(None, None, None)
+            else:
+                # Clean the specific sandbox
+                self.manager_api.release(self.sandbox_id)
+        except Exception as e:
+            logger.error(
+                f"Cleanup {self.sandbox_id} error: {e}",
+            )
+
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
-        # Remote not need to close the embed_manager
-        if self.embed_mode:
-            # Clean all
-            self.manager_api.__exit__(exc_type, exc_value, traceback)
-        else:
-            # Clean the specific sandbox
-            self.manager_api.release(self.sandbox_id)
+        self._cleanup()
 
     @property
     def sandbox_id(self) -> str:

agentscope_runtime/sandbox/box/shared/routers/mcp_utils.py

@@ -41,6 +41,8 @@ class MCPSessionHandler:
                     command=command,
                     args=self.config.get("args", []),
                     env={**os.environ, **self.config.get("env", {})},
+                    # cwd=self.config.get("cwd"),  # Disabled
+                    encoding=self.config.get("encoding", "utf-8"),
                 )
 
                 streams = await self._exit_stack.enter_async_context(
@@ -52,12 +54,28 @@ class MCPSessionHandler:
                     "streamableHttp",
                 ]:
                     streams = await self._exit_stack.enter_async_context(
-                        streamablehttp_client(url=self.config["url"]),
+                        streamablehttp_client(
+                            url=self.config["url"],
+                            headers=self.config.get("headers"),
+                            timeout=self.config.get("timeout", 30),
+                            sse_read_timeout=self.config.get(
+                                "sse_read_timeout",
+                                60 * 5,
+                            ),
+                        ),
                     )
                     streams = (streams[0], streams[1])
                 else:
                     streams = await self._exit_stack.enter_async_context(
-                        sse_client(url=self.config["url"]),
+                        sse_client(
+                            url=self.config["url"],
+                            headers=self.config.get("headers"),
+                            timeout=self.config.get("timeout", 30),
+                            sse_read_timeout=self.config.get(
+                                "sse_read_timeout",
+                                60 * 5,
+                            ),
+                        ),
                     )
             session = await self._exit_stack.enter_async_context(
                 ClientSession(*streams),

agentscope_runtime/sandbox/box/training_box/env_service.py

@@ -749,4 +749,4 @@ if __name__ == "__main__":
         sys.exit(1)
 
     print(f"Starting server on {args.portal}:{args.port}")
-    uvicorn.run(app, host=args.portal, port=args.port)
+    uvicorn.run(app, host=args.portal, port=args.port, log_level="error")

agentscope_runtime/sandbox/box/training_box/environments/bfcl/bfcl_dataprocess.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""
+BFCL数据预处理脚本 - 数据处理与分割工具
+
+脚本用途：
+1. 加载指定测试类别的用例
+2. 对测试用例进行预处理，加载工具集合schema
+3. 将数据集按指定比例分割为训练集和测试集
+4. 分别保存数据文件和ID文件
+
+使用示例：
+result = bfcl_task_preprocess(
+    test_categories=["multi_turn_base"],  # 指定测试类别
+    train_ratio=0.5,                      # 训练集占50%
+    output_dir="/path/to/output"           # 输出目录
+)
+
+生成两个文件：
+{类别}_processed.jsonl：处理后的数据集
+{类别}_split_ids.json：训练/测试集ID
+
+"""
+
+from typing import List, Dict, Any, Optional
+import json
+import random
+from pathlib import Path
+
+from bfcl_eval.constants.eval_config import (
+    PROMPT_PATH,
+)
+from bfcl_eval.eval_checker.eval_runner_helper import load_file
+from bfcl_eval.utils import (
+    parse_test_category_argument,
+    populate_test_cases_with_predefined_functions,
+)
+
+
+TEST_FILE_MAPPING = {
+    "simple": "BFCL_v4_simple.json",
+    "irrelevance": "BFCL_v4_irrelevance.json",
+    "parallel": "BFCL_v4_parallel.json",
+    "multiple": "BFCL_v4_multiple.json",
+    "parallel_multiple": "BFCL_v4_parallel_multiple.json",
+    "java": "BFCL_v4_java.json",
+    "javascript": "BFCL_v4_javascript.json",
+    "live_simple": "BFCL_v4_live_simple.json",
+    "live_multiple": "BFCL_v4_live_multiple.json",
+    "live_parallel": "BFCL_v4_live_parallel.json",
+    "live_parallel_multiple": "BFCL_v4_live_parallel_multiple.json",
+    "live_irrelevance": "BFCL_v4_live_irrelevance.json",
+    "live_relevance": "BFCL_v4_live_relevance.json",
+    "multi_turn_base": "BFCL_v4_multi_turn_base.json",
+    "multi_turn_miss_func": "BFCL_v4_multi_turn_miss_func.json",
+    "multi_turn_miss_param": "BFCL_v4_multi_turn_miss_param.json",
+    "multi_turn_long_context": "BFCL_v4_multi_turn_long_context.json",
+}
+
+
+def bfcl_task_preprocess(
+    test_categories: Optional[List[str]] = None,
+    train_ratio: float = 0.5,
+    random_seed: int = 42,
+    output_dir: str = "",
+    enable_shuffle: bool = False,
+) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    Preprocess training dataset by loading test cases, processing them and
+    splitting into train/test sets.
+
+    Args:
+        test_categories: List of test categories to process. Can be specific
+        category names or collection names
+                (e.g. 'all', 'multi_turn'). If None, process all categories.
+        train_ratio: Ratio for training set split, range [0, 1]. If 1.0, no
+        split is performed.
+        random_seed: Random seed for reproducible data splitting.
+        output_dir: Output directory path.
+        output_prefix: Prefix for output files.
+        save_by_category: Whether to save files separately by category.
+        save_parquet: Whether to save parquet files.
+        enable_export_verl_data_schema: Whether to export data in verl format
+        schema.
+    Returns:
+        Dict containing train and test sets: {'train': [...], 'test': [...]}
+    """
+
+    def load_selected_test_cases(categories: List[str]):
+        all_test_entries_by_category = {}
+
+        try:
+            test_categories_resolved = parse_test_category_argument(categories)
+        except Exception as e:
+            print(f"Error: Invalid test categories - {str(e)}")
+            return {}
+
+        print(f"Selected test categories: {test_categories_resolved}")
+
+        for category in test_categories_resolved:
+            if category in TEST_FILE_MAPPING:
+                test_file_path = TEST_FILE_MAPPING[category]
+                test_entries = load_file(PROMPT_PATH / test_file_path)
+                print(f"Loaded {len(test_entries)} test cases from {category}")
+                if category not in all_test_entries_by_category:
+                    all_test_entries_by_category[category] = []
+                all_test_entries_by_category[category].extend(test_entries)
+
+        return all_test_entries_by_category
+
+    random.seed(random_seed)
+
+    if test_categories is None:
+        test_categories = ["all"]
+
+    all_test_cases_by_category = load_selected_test_cases(test_categories)
+
+    if not all_test_cases_by_category:
+        print("Warning: No test cases found")
+        return {"train": [], "test": []}
+
+    total_cases = sum(
+        len(cases) for cases in all_test_cases_by_category.values()
+    )
+    print(
+        f"Loaded {total_cases} test cases in total across \
+            {len(all_test_cases_by_category)} categories",
+    )
+
+    all_processed_cases = []
+    processed_cases_by_category = {}
+
+    for category, test_cases in all_test_cases_by_category.items():
+        print(f"Processing category: {category}")
+
+        category_processed_cases = (
+            populate_test_cases_with_predefined_functions(test_cases)
+        )
+        processed_cases_by_category[category] = category_processed_cases
+        all_processed_cases.extend(category_processed_cases)
+        print(
+            f"Successfully processed {len(category_processed_cases)} test \
+                cases for {category}",
+        )
+
+    print(
+        f"Successfully processed {len(all_processed_cases)} test \
+            cases in total",
+    )
+
+    if enable_shuffle:
+        random.shuffle(all_processed_cases)
+    train_size = int(len(all_processed_cases) * train_ratio)
+    train_cases = all_processed_cases[:train_size]
+    test_cases = all_processed_cases[train_size:]
+    print(
+        f"Data split complete: {len(train_cases)} training, \
+            {len(test_cases)} test cases",
+    )
+
+    case_result = {"train": train_cases, "test": test_cases}
+
+    if output_dir:
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        test_categories_str = "_".join(test_categories)
+
+        full_jsonl_path = (
+            output_path / f"{test_categories_str}_processed.jsonl"
+        )
+        with open(full_jsonl_path, "w", encoding="utf-8") as f:
+            for case in all_processed_cases:
+                f.write(json.dumps(case, ensure_ascii=False) + "\n")
+        print(f"Full dataset saved to: {full_jsonl_path}")
+
+        split_ids = {
+            "train": [
+                case.get("id", idx) for idx, case in enumerate(train_cases)
+            ],
+            "val": [
+                case.get("id", idx) for idx, case in enumerate(test_cases)
+            ],
+        }
+
+        split_ids_path = output_path / f"{test_categories_str}_split_ids.json"
+        with open(split_ids_path, "w", encoding="utf-8") as f:
+            json.dump(split_ids, f, ensure_ascii=False, indent=2)
+        print(f"Split IDs saved to: {split_ids_path}")
+
+    return case_result
+
+
+if __name__ == "__main__":
+    category_list = [
+        "all",
+        "all_scoring",
+        "multi_turn",
+        "single_turn",
+        "live",
+        "non_live",
+        "non_python",
+        "python",
+    ]
+
+    for bfcl_category in category_list:
+        result = bfcl_task_preprocess(
+            test_categories=[bfcl_category],
+            train_ratio=0.5,
+            output_dir="./bfcl/multi_turn",
+        )
+
+        print("-" * 50)
+        print("Processing complete!")
+        if result["train"]:
+            print(f"Training samples: {len(result['train'])}")
+        if result["test"]:
+            print(f"Test samples: {len(result['test'])}")