beswarm 0.1.91__py3-none-any.whl → 0.1.92__py3-none-any.whl

beswarm/aient/src/aient/core/request.py

@@ -341,7 +341,8 @@ async def get_vertex_gemini_payload(request, engine, provider, api_key=None):
     else:
         location = gemini1
 
-    if "gemini-2.5-pro-exp-03-25" == original_model or "gemini-2.5-pro-preview-06-05" == original_model:
+    if "gemini-2.5-flash-lite-preview-06-17" == original_model or \
+    "gemini-2.5-pro-preview-06-05" == original_model:
         location = gemini2_5_pro_exp
 
     if "google-vertex-ai" in provider.get("base_url", ""):
@@ -362,7 +363,8 @@ async def get_vertex_gemini_payload(request, engine, provider, api_key=None):
         else:
             url = f"https://aiplatform.googleapis.com/v1/publishers/google/models/{original_model}:{gemini_stream}?key={api_key}"
         headers.pop("Authorization", None)
-    elif "gemini-2.5-pro-exp-03-25" == original_model or "gemini-2.5-pro-preview-06-05" == original_model:
+    elif "gemini-2.5-flash-lite-preview-06-17" == original_model or \
+    "gemini-2.5-pro-preview-06-05" == original_model:
         url = "https://aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{LOCATION}/publishers/google/models/{MODEL_ID}:{stream}".format(
             LOCATION=await location.next(),
             PROJECT_ID=project_id,

beswarm/bemcp/bemcp/__init__.py

@@ -0,0 +1,4 @@
+from .main import MCPManager, MCPClient
+from .utils import convert_tool_format
+
+__all__ = ["MCPManager", "MCPClient", "convert_tool_format"]

beswarm/bemcp/bemcp/main.py

@@ -0,0 +1,220 @@
+import asyncio
+from typing import Any, Dict, List, Optional
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.client.sse import sse_client
+import mcp.types as types
+
+class MCPClient:
+    """
+    A client for interacting with a single Model Context Protocol (MCP) server.
+    It can connect to a server via stdio or a URL (SSE).
+    This class is an asynchronous context manager.
+    """
+    def __init__(self, server_config: Dict[str, Any]):
+        """
+        Initializes the MCPClient.
+
+        Args:
+            server_config: A dictionary containing server configuration.
+                           It should have either 'command' and 'args' for stdio,
+                           or 'url' for SSE.
+        """
+        if not ("command" in server_config or "url" in server_config):
+            raise ValueError("Server config must contain 'command' or 'url'")
+        self.server_config = server_config
+        self.session: Optional[ClientSession] = None
+        self._exit_stack: Optional[AsyncExitStack] = None
+
+    async def connect(self):
+        """Connects to the MCP server and initializes resources."""
+        return await self.__aenter__()
+
+    async def disconnect(self):
+        """Disconnects from the MCP server and cleans up resources."""
+        return await self.__aexit__(None, None, None)
+
+    async def __aenter__(self):
+        """Connects to the MCP server and initializes resources."""
+        if self.session:
+            return self
+
+        self._exit_stack = AsyncExitStack()
+        try:
+            if "command" in self.server_config:
+                server_params = StdioServerParameters(**self.server_config)
+                transport = await self._exit_stack.enter_async_context(stdio_client(server_params))
+            else:
+                transport = await self._exit_stack.enter_async_context(sse_client(**self.server_config))
+
+            read_stream, write_stream = transport
+            self.session = await self._exit_stack.enter_async_context(ClientSession(read_stream, write_stream))
+            await self.session.initialize()
+            print(f"Connected to server.")
+            return self
+        except Exception:
+            # If setup fails, make sure to clean up anything that was started.
+            if self._exit_stack:
+                await self._exit_stack.aclose()
+            raise
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        """Disconnects from the MCP server and cleans up resources."""
+        if self._exit_stack:
+            await self._exit_stack.aclose()
+            self.session = None
+            self._exit_stack = None
+            print("Disconnected from server.")
+
+    async def list_tools(self) -> List[types.Tool]:
+        """Lists available tools from the server."""
+        if not self.session:
+            raise ConnectionError("Not connected to any server.")
+        response = await self.session.list_tools()
+        return response.tools
+
+    async def call_tool(self, name: str, args: Dict[str, Any]) -> types.CallToolResult:
+        """Calls a tool on the server."""
+        if not self.session:
+            raise ConnectionError("Not connected to any server.")
+        return await self.session.call_tool(name, args)
+
+    async def list_resources(self) -> List[types.Resource]:
+        """Lists available resources from the server."""
+        if not self.session:
+            raise ConnectionError("Not connected to any server.")
+        response = await self.session.list_resources()
+        return response.resources
+
+    async def read_resource(self, uri: str) -> types.ReadResourceResult:
+        """Reads a resource from the server."""
+        if not self.session:
+            raise ConnectionError("Not connected to any server.")
+        return await self.session.read_resource(uri)
+
+
+class MCPManager:
+    """
+    Manages connections to multiple MCP servers.
+    """
+    def __init__(self):
+        self.clients: Dict[str, MCPClient] = {}
+        self._exit_stack = AsyncExitStack()
+
+    async def add_server(self, name: str, config: Dict[str, Any]):
+        """
+        Adds and connects to a new MCP server.
+
+        Args:
+            name: A unique name for the server.
+            config: The server configuration dictionary.
+        """
+        if name in self.clients:
+            print(f"Server '{name}' already exists.")
+            return
+
+        client = MCPClient(config)
+        await self._exit_stack.enter_async_context(client)
+        self.clients[name] = client
+        print(f"Server '{name}' added and connected.")
+
+    async def remove_server(self, name: str):
+        """
+        Disconnects and removes an MCP server.
+        """
+        # NOTE: With the new ExitStack-based management, removing a single
+        # server is complex. This method is left as a placeholder and will
+        # not correctly clean up resources for the removed server.
+        if name in self.clients:
+            del self.clients[name]
+            print(f"Server '{name}' removed (Warning: resources may not be cleaned up immediately).")
+        else:
+            print(f"Server '{name}' not found.")
+
+    async def get_all_tools(self) -> Dict[str, List[types.Tool]]:
+        """Gets a dictionary of all tools from all connected servers."""
+        all_tools = {}
+        for name, client in self.clients.items():
+            try:
+                tools = await client.list_tools()
+                all_tools[name] = tools
+            except Exception as e:
+                print(f"Error getting tools from server '{name}': {e}")
+        return all_tools
+
+    async def call_tool(self, server_name: str, tool_name: str, args: Dict[str, Any]) -> types.CallToolResult:
+        """
+        Calls a specific tool on a specific server.
+        """
+        if server_name not in self.clients:
+            raise ValueError(f"Server '{server_name}' not found.")
+        return await self.clients[server_name].call_tool(tool_name, args)
+
+    async def cleanup(self):
+        """Disconnects all clients by closing the manager's exit stack."""
+        if self.clients:
+            await self._exit_stack.aclose()
+            self.clients.clear()
+
+async def test_bemcp():
+    """
+    Test function for MCPManager and MCPClient.
+    """
+    manager = MCPManager()
+
+    # Configuration for a test server (using the existing test/server.py)
+    test_server_config = {
+        "command": "uv",
+        "args": ["run", "test/server.py"],
+        "env": None
+    }
+
+    # Add the test server
+    await manager.add_server("test_server", test_server_config)
+
+    # List all tools
+    all_tools = await manager.get_all_tools()
+    print("\n--- All Tools ---")
+    for server_name, tools in all_tools.items():
+        print(f"Server: {server_name}")
+        for tool in tools:
+            print(f"  - {tool.name}: {tool.description}")
+    print("-------------------\n")
+
+    # Call a tool
+    print("--- Calling 'add' tool on 'test_server' with a=2, b=3 ---")
+    try:
+        result = await manager.call_tool("test_server", "add", {"a": 2, "b": 3})
+        print("Result:", result.content[0].text)
+    except Exception as e:
+        print(f"Error calling tool: {e}")
+    print("--------------------------------------------------------\n")
+
+    # Call another tool
+    print("--- Calling 'calculate_bmi' tool on 'test_server' with weight_kg=70, height_m=1.75 ---")
+    try:
+        result = await manager.call_tool("test_server", "calculate_bmi", {"weight_kg": 70, "height_m": 1.75})
+        print("Result:", result.content[0].text)
+    except Exception as e:
+        print(f"Error calling tool: {e}")
+    print("-------------------------------------------------------------------------------------\n")
+
+    # Read a resource
+    print("--- Reading resource 'config://app' from 'test_server' ---")
+    client = manager.clients.get("test_server")
+    if client:
+        try:
+            resource_result = await client.read_resource('config://app')
+            print("Resource content:", resource_result.contents[0].text)
+        except Exception as e:
+            print(f"Error reading resource: {e}")
+    print("----------------------------------------------------------\n")
+
+
+    # Clean up
+    await manager.cleanup()
+
+if __name__ == "__main__":
+    asyncio.run(test_bemcp())

beswarm/bemcp/bemcp/utils.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict
+from mcp import types
+
+def convert_tool_format(tool: types.Tool) -> Dict[str, Any]:
+    """
+    Converts an MCP tool to a format compatible with LLM providers.
+    """
+    # This is one possible format, similar to OpenAI's function calling.
+    # The commented-out section shows another common variation.
+    # converted_tool = {
+    #     "type": "function",
+    #     "function": {
+    #         "name": tool.name,
+    #         "description": tool.description,
+    #         "parameters": {
+    #             "type": "object",
+    #             "properties": tool.inputSchema["properties"],
+    #             "required": tool.inputSchema["required"]
+    #         }
+    #     }
+    # }
+    converted_tool = {
+        "type": "function",
+        "function": {
+            "name": tool.name,
+            "description": tool.description,
+            "input_schema": tool.inputSchema
+        }
+    }
+    return converted_tool

beswarm/bemcp/test/client.py

@@ -0,0 +1,49 @@
+import asyncio
+
+from mcp.client.stdio import stdio_client
+from mcp import ClientSession, StdioServerParameters
+
+# 为 stdio 连接创建服务器参数
+server_params = StdioServerParameters(
+    # 服务器执行的命令，这里我们使用 uv 来运行 web_search.py
+    command='uv',
+    # 运行的参数
+    args=['run', 'server.py'],
+    # 环境变量，默认为 None，表示使用当前环境变量
+    # env=None
+)
+
+
+async def main():
+    # 创建 stdio 客户端
+    async with stdio_client(server_params) as (stdio, write):
+        # 创建 ClientSession 对象
+        async with ClientSession(stdio, write) as session:
+            # 初始化 ClientSession
+            await session.initialize()
+
+            # 列出可用的工具
+            response = await session.list_tools()
+            print(response.model_dump_json(indent=2))
+
+            response = await session.list_resources()
+            print(response.model_dump_json(indent=2))
+
+            response = await session.list_prompts()
+            print(response.model_dump_json(indent=2))
+
+            # 调用工具
+            response = await session.call_tool('add', {"a": "2", "b": "3"})
+            print(response.model_dump_json(indent=2))
+
+            # 调用工具
+            response = await session.read_resource('config://app')
+            print(response.model_dump_json(indent=2))
+
+            # 调用工具
+            response = await session.get_prompt('debug_error', {"error": "test"})
+            print(response.model_dump_json(indent=2))
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

beswarm/bemcp/test/server.py

@@ -0,0 +1,43 @@
+# server.py
+import httpx
+from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp.prompts import base
+
+# Create an MCP server
+mcp = FastMCP("Demo")
+
+
+# Add an addition tool
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+
+@mcp.tool()
+def calculate_bmi(weight_kg: float, height_m: float) -> float:
+    """Calculate BMI given weight in kg and height in meters"""
+    return weight_kg / (height_m**2)
+
+@mcp.tool()
+async def fetch_weather(city: str) -> str:
+    """Fetch current weather for a city"""
+    async with httpx.AsyncClient() as client:
+        response = await client.get(f"https://api.weather.com/{city}")
+        return response.text
+
+@mcp.resource("config://app")
+def get_config() -> str:
+    """Static configuration data"""
+    return "App configuration here"
+
+@mcp.prompt()
+def debug_error(error: str) -> list[base.Message]:
+    return [
+        base.UserMessage("I'm seeing this error:"),
+        base.UserMessage(error),
+        base.AssistantMessage("I'll help debug that. What have you tried so far?"),
+    ]
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')
+    # mcp.run(transport='sse')

beswarm/tools/worker.py

@@ -7,9 +7,12 @@ from pathlib import Path
 from datetime import datetime
 
 from ..aient.src.aient.models import chatgpt
-from ..aient.src.aient.plugins import register_tool, get_function_call_list
+from ..aient.src.aient.plugins import register_tool, get_function_call_list, registry
 from ..prompt import worker_system_prompt, instruction_system_prompt
-from ..utils import extract_xml_content, get_current_screen_image_message, replace_xml_content
+from ..utils import extract_xml_content, get_current_screen_image_message, replace_xml_content, register_mcp_tools
+from ..bemcp.bemcp import MCPClient, convert_tool_format, MCPManager
+
+manager = MCPManager()
 
 @register_tool()
 async def worker(goal, tools, work_dir, cache_messages=None):
@@ -31,6 +34,19 @@ async def worker(goal, tools, work_dir, cache_messages=None):
     start_time = datetime.now()
     finish_flag = 0
 
+    mcp_list = [item for item in tools if isinstance(item, dict)]
+    if mcp_list:
+        for mcp_item in mcp_list:
+            mcp_name, mcp_config = list(mcp_item.items())[0]
+            await manager.add_server(mcp_name, mcp_config)
+            client = manager.clients.get(mcp_name)
+            await register_mcp_tools(client, registry)
+        all_tools = await manager.get_all_tools()
+        mcp_tools_name = [tool.name for tool in sum(all_tools.values(), [])]
+        tools += mcp_tools_name
+
+    tools = [item for item in tools if not isinstance(item, dict)]
+
     tools_json = [value for _, value in get_function_call_list(tools).items()]
     work_agent_system_prompt = worker_system_prompt.format(
         os_version=platform.platform(),
@@ -179,11 +195,26 @@ async def worker(goal, tools, work_dir, cache_messages=None):
     print(f"\n任务开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
     print(f"任务结束时间: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
     print(f"总用时: {total_time}")
+    await manager.cleanup()
     return "任务已完成"
 
 async def worker_gen(goal, tools, work_dir, cache_messages=None):
     start_time = datetime.now()
     finish_flag = 0
+
+    mcp_list = [item for item in tools if isinstance(item, dict)]
+    if mcp_list:
+        for mcp_item in mcp_list:
+            mcp_name, mcp_config = list(mcp_item.items())[0]
+            await manager.add_server(mcp_name, mcp_config)
+            client = manager.clients.get(mcp_name)
+            await register_mcp_tools(client, registry)
+        all_tools = await manager.get_all_tools()
+        mcp_tools_name = [tool.name for tool in sum(all_tools.values(), [])]
+        tools += mcp_tools_name
+
+    tools = [item for item in tools if not isinstance(item, dict)]
+
     tools_json = [value for _, value in get_function_call_list(tools).items()]
     work_agent_system_prompt = worker_system_prompt.format(
         os_version=platform.platform(),
@@ -335,4 +366,5 @@ async def worker_gen(goal, tools, work_dir, cache_messages=None):
     total_time = end_time - start_time
     print(f"\n任务开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
     print(f"任务结束时间: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
-    print(f"总用时: {total_time}")
+    print(f"总用时: {total_time}")
+    await manager.cleanup()

beswarm/utils.py

@@ -68,6 +68,102 @@ async def get_current_screen_image_message(prompt):
     message_list.append(image_message)
     return message_list
 
+import asyncio
+from .bemcp.bemcp import MCPClient, convert_tool_format
+
+async def register_mcp_tools(mcp_client: MCPClient, registry: "Registry"):
+    """
+    Fetches tools from an MCP client, dynamically creates corresponding
+    Python functions with correct signatures, and registers them using the
+    provided registry instance.
+    """
+    try:
+        mcp_tools = await mcp_client.list_tools()
+        print(f"Found {len(mcp_tools)} tools on the MCP server.")
+    except Exception as e:
+        print(f"Error fetching tools from MCP server: {e}")
+        return
+
+    # Create a dummy file for inspect.getsource to work with exec
+    # This helps make the created functions inspectable
+    source_storage = {}
+
+    for tool in mcp_tools:
+        openai_spec = convert_tool_format(tool)
+        func_spec = openai_spec.get('function', {})
+
+        tool_name = func_spec.get('name')
+        if not tool_name or not tool_name.isidentifier():
+            print(f"Skipping tool with invalid name: {tool_name}")
+            continue
+
+        description = func_spec.get('description', 'No description available.')
+        params_spec = func_spec.get('parameters', {})
+        properties = params_spec.get('properties', {})
+        required = set(params_spec.get('required', []))
+
+        param_defs = []
+        for name, spec in properties.items():
+            if name in required:
+                param_defs.append(name)
+            else:
+                # Add default value for optional parameters
+                default = spec.get('default', 'None')
+                param_defs.append(f"{name}={default}")
+
+        params_str = ", ".join(param_defs)
+        arg_names = list(properties.keys())
+        # Create a dictionary of arguments to pass to call_tool
+        args_dict_str = "{" + ", ".join(f"'{k}': {k}" for k in arg_names) + "}"
+
+        # Dynamically generate the Python source code for the function
+        func_source = f"""
+async def {tool_name}({params_str}):
+    \"\"\"{description}\"\"\"
+    tool_args = {args_dict_str}
+
+    # This function is a dynamically generated wrapper for an MCP tool.
+    print(f"-> Calling MCP tool '{tool_name}' with args: {{tool_args}}")
+    result = await mcp_client.call_tool('{tool_name}', tool_args)
+
+    # Extract text content if available, otherwise return the raw result
+    if hasattr(result, 'content') and isinstance(result.content, list) and result.content:
+        if hasattr(result.content[0], 'text'):
+            return result.content[0].text
+    return result
+"""
+        # Store the source code so inspect.getsource can find it
+        source_storage[tool_name] = func_source
+
+        # Use a dictionary for the execution scope
+        exec_scope = {'mcp_client': mcp_client, 'asyncio': asyncio}
+
+        try:
+            # Execute the source code to create the function object
+            exec(func_source, exec_scope)
+            generated_func = exec_scope[tool_name]
+
+            # Monkey-patch getsourcelines to work with our storage
+            # This makes our generated function fully compatible with the registry
+            import inspect
+            import linecache
+            linecache.cache[f"<mcp_adapter/{tool_name}>"] = (
+                len(func_source),
+                None,
+                [line + '\n' for line in func_source.splitlines()],
+                f"<mcp_adapter/{tool_name}>",
+            )
+            generated_func.__code__ = generated_func.__code__.replace(co_filename=f"<mcp_adapter/{tool_name}>")
+
+            # Register the newly created function
+            registry.register(type="tool", name=tool_name)(generated_func)
+            print(f"Successfully registered MCP tool: '{tool_name}'")
+
+        except Exception as e:
+            import traceback
+            print(f"Failed to create or register function for tool '{tool_name}': {e}")
+            traceback.print_exc()
+
 if __name__ == "__main__":
     print(extract_xml_content("<instructions>\n123</instructions>", "instructions"))
 

{beswarm-0.1.91.dist-info → beswarm-0.1.92.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beswarm
-Version: 0.1.91
+Version: 0.1.92
 Summary: MAS
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -11,6 +11,7 @@ Requires-Dist: fastapi>=0.115.12
 Requires-Dist: grep-ast>=0.8.1
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: httpx-socks>=0.10.0
+Requires-Dist: mcp[cli]>=1.9.4
 Requires-Dist: msgspec>=0.19.0
 Requires-Dist: networkx>=3.4.2
 Requires-Dist: numpy>=2.2.5

{beswarm-0.1.91.dist-info → beswarm-0.1.92.dist-info}/RECORD

@@ -1,13 +1,13 @@
 beswarm/__init__.py,sha256=HZjUOJtZR5QhMuDbq-wukQQn1VrBusNWai_ysGo-VVI,20
 beswarm/prompt.py,sha256=cBz8sSmFj0edIGOZjCMg0rg3pFXQYo8xGvXSA8Py1hg,31591
-beswarm/utils.py,sha256=cOYwuONpNG_dkSYIvdEqQOxRUdIy0Bh9CTYkvKKskdw,2816
+beswarm/utils.py,sha256=lm0drN1ebXM9haoKaW2DLzJJRCOpLmiJ864mH4jAdB4,6697
 beswarm/aient/main.py,sha256=SiYAIgQlLJqYusnTVEJOx1WNkSJKMImhgn5aWjfroxg,3814
 beswarm/aient/setup.py,sha256=IUr9oCEhGFNVvz7v8J9tedwE_JK6Hlf8XpnENoq2K2s,487
 beswarm/aient/src/aient/__init__.py,sha256=SRfF7oDVlOOAi6nGKiJIUK6B_arqYLO9iSMp-2IZZps,21
 beswarm/aient/src/aient/core/__init__.py,sha256=NxjebTlku35S4Dzr16rdSqSTWUvvwEeACe8KvHJnjPg,34
 beswarm/aient/src/aient/core/log_config.py,sha256=kz2_yJv1p-o3lUQOwA3qh-LSc3wMHv13iCQclw44W9c,274
 beswarm/aient/src/aient/core/models.py,sha256=oUGsytAVBuhE_MLco7PqIQGwWD8lEYkZxgb8HEuynmA,7444
-beswarm/aient/src/aient/core/request.py,sha256=Zp5Q6iZp3OWZt95cZLh0VmbwvF18jXQB88UfA_3AKt8,67279
+beswarm/aient/src/aient/core/request.py,sha256=7IaN5iFYQgDK9W8ej-OZCom4bSZiPN5t_S_91DBRb28,67313
 beswarm/aient/src/aient/core/response.py,sha256=WIJhvf3Th3-XW3MsDq8QdzxXcNe5q1mCKcCZx8pzm2A,33213
 beswarm/aient/src/aient/core/utils.py,sha256=zidsBUBd3KskzcxQcPB1y5x1RhtWcbZeWvmgb4LAadA,27318
 beswarm/aient/src/aient/core/test/test_base_api.py,sha256=pWnycRJbuPSXKKU9AQjWrMAX1wiLC_014Qc9hh5C2Pw,524
@@ -71,6 +71,11 @@ beswarm/aient/test/test_url.py,sha256=ASE3kT2-ooaX6Flw4botjXnuqaBgutqRWPx3fow5nL
 beswarm/aient/test/test_whisper.py,sha256=GxKYzhh3lA8t62V_DDj42VQTXkdjocSFcl5u96WF580,378
 beswarm/aient/test/test_wildcard.py,sha256=EQwwNrTMHV4CEcZKdwUVGrwtNUsF0CCKbM-_W9IOYsk,693
 beswarm/aient/test/test_yjh.py,sha256=MsHuBLNOqi3fyX-uboBKmTevkZW_KVv12p-pkF5ir3Y,787
+beswarm/bemcp/bemcp/__init__.py,sha256=Ss6bDXiZJgVIZS6KWytcGwXmIFu7SsagIXa5NpeWJ7c,140
+beswarm/bemcp/bemcp/main.py,sha256=dadyyAv0yzEX5EYnBM14SmBN7X3keJTrheDVie2rVJ4,8370
+beswarm/bemcp/bemcp/utils.py,sha256=YDRa4JvBjdNTJBzbrkwRXmRXy2gw8s9lb61WsnYZN10,953
+beswarm/bemcp/test/client.py,sha256=j7PDg5Esyri-e2vz2ubZ4foDSAq5Iv8Yfl_xyzTDsFY,1593
+beswarm/bemcp/test/server.py,sha256=58F0_xQTHc6mt_MTXLSz_JE1COzDdEYueco1OVuFay0,1159
 beswarm/queries/tree-sitter-language-pack/README.md,sha256=ivZSEuWqYfUVLZl2AZZGRlm0bQsaG-VTBKBwACyM07k,291
 beswarm/queries/tree-sitter-language-pack/arduino-tags.scm,sha256=HbgdothT9Jjk56COXTtUkVAdZ14rZNnqzLbWVLeRs5U,177
 beswarm/queries/tree-sitter-language-pack/c-tags.scm,sha256=EIz45o5hBh8yEuck5ZR_4IpcGyWSeNrzxFmtkKZGt2k,461
@@ -128,8 +133,8 @@ beswarm/tools/screenshot.py,sha256=u6t8FCgW5YHJ_Oc4coo8e0F3wTusWE_-H8dFh1rBq9Q,1
 beswarm/tools/search_arxiv.py,sha256=GpuIOYX8T0iRC-X-hmuR9AUJVn15WWZq864DaoC7BUc,8004
 beswarm/tools/search_web.py,sha256=B24amOnGHnmdV_6S8bw8O2PdhZRRIDtJjg-wXcfP7dQ,11859
 beswarm/tools/think.py,sha256=WLw-7jNIsnS6n8MMSYUin_f-BGLENFmnKM2LISEp0co,1760
-beswarm/tools/worker.py,sha256=o24fkVGVXQ3eVLZFpYozMv5fas-Wc269dLCFKqOeaSI,16275
-beswarm-0.1.91.dist-info/METADATA,sha256=JjbdA88aNFt2ipP1J3JEeVFpQ4lMDoL5zyv4CpLnIUs,3553
-beswarm-0.1.91.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-beswarm-0.1.91.dist-info/top_level.txt,sha256=pJw4O87wvt5882smuSO6DfByJz7FJ8SxxT8h9fHCmpo,8
-beswarm-0.1.91.dist-info/RECORD,,
+beswarm/tools/worker.py,sha256=hqfOOW0PeLHYgmB2eHPIPd4wpI_RMsDGGkH5DMy0SLo,17597
+beswarm-0.1.92.dist-info/METADATA,sha256=5b6zhFvaxJGQxuoaSMYmM4jsoiaQTNx7JTqsVfMvLp8,3584
+beswarm-0.1.92.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+beswarm-0.1.92.dist-info/top_level.txt,sha256=pJw4O87wvt5882smuSO6DfByJz7FJ8SxxT8h9fHCmpo,8
+beswarm-0.1.92.dist-info/RECORD,,