bohr-agent-sdk 0.1.110__tar.gz → 0.1.112__tar.gz

{bohr_agent_sdk-0.1.110 → bohr_agent_sdk-0.1.112}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bohr-agent-sdk
-Version: 0.1.110
+Version: 0.1.112
 Summary: SDK for scientific agents
 Home-page: https://github.com/dptech-corp/bohr-agent-sdk/
 Author: DP Technology

{bohr_agent_sdk-0.1.110 → bohr_agent_sdk-0.1.112}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="bohr-agent-sdk",
-    version="0.1.110",
+    version="0.1.112",
     description="SDK for science agent and mcp tools",
     long_description=long_description,
     long_description_content_type="text/markdown",

{bohr_agent_sdk-0.1.110 → bohr_agent_sdk-0.1.112}/src/bohr_agent_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bohr-agent-sdk
-Version: 0.1.110
+Version: 0.1.112
 Summary: SDK for scientific agents
 Home-page: https://github.com/dptech-corp/bohr-agent-sdk/
 Author: DP Technology

{bohr_agent_sdk-0.1.110 → bohr_agent_sdk-0.1.112}/src/dp/agent/client/mcp_client.py

@@ -125,7 +125,7 @@ class MCPClient:
 
         executor = arguments.get("executor")
         storage = arguments.get("storage")
-        res = await self.session.call_tool("submit_" + tool_name, arguments)
+        res = await self.call_tool("submit_" + tool_name, arguments)
         if res.isError:
             logger.error("Failed to submit %s: %s" % (
                 tool_name, res.content[0].text))
@@ -137,7 +137,7 @@ class MCPClient:
             logger.info(job_info["extra_info"])
 
         while True:
-            res = await self.session.call_tool("query_job_status", {
+            res = await self.call_tool("query_job_status", {
                 "job_id": job_id, "executor": executor})
             if res.isError:
                 logger.error(res.content[0].text)
@@ -148,7 +148,7 @@ class MCPClient:
                     break
             await asyncio.sleep(self.query_interval)
 
-        res = await self.session.call_tool("get_job_results", {
+        res = await self.call_tool("get_job_results", {
             "job_id": job_id, "executor": executor, "storage": storage})
         if res.isError:
             logger.error("Job %s failed: %s" % (job_id, res.content[0].text))

{bohr_agent_sdk-0.1.110 → bohr_agent_sdk-0.1.112}/src/dp/agent/server/calculation_mcp_server.py

@@ -7,17 +7,17 @@ from copy import deepcopy
 from datetime import datetime
 from pathlib import Path
 from urllib.parse import urlparse
-from typing import Any, Literal, Optional, TypedDict
+from typing import Annotated, Literal, Optional, List, Dict
 
-import mcp
 from mcp.server.fastmcp import FastMCP
 from mcp.server.fastmcp.utilities.context_injection import (
     find_context_parameter,
 )
 from mcp.server.fastmcp.utilities.func_metadata import (
-    _get_typed_signature,
+    ArgModelBase,
     func_metadata,
 )
+from pydantic import BaseModel, Field, create_model
 from starlette.responses import JSONResponse
 from starlette.routing import Route
 
@@ -65,18 +65,9 @@ def set_directory(workdir: str):
         os.chdir(cwd)
 
 
-def load_executor(executor):
-    if not executor and os.path.exists("executor.json"):
-        with open("executor.json", "r") as f:
-            executor = json.load(f)
-    return executor
-
-
-def load_storage(storage):
-    if not storage and os.path.exists("storage.json"):
-        with open("storage.json", "r") as f:
-            storage = json.load(f)
-    return storage
+def load_job_info():
+    with open("job.json", "r") as f:
+        return json.load(f)
 
 
 def query_job_status(job_id: str, executor: Optional[dict] = None
@@ -90,7 +81,7 @@ def query_job_status(job_id: str, executor: Optional[dict] = None
     """
     trace_id, exec_id = job_id.split("/")
     with set_directory(trace_id):
-        executor = load_executor(executor)
+        executor = load_job_info()["executor"] or executor
         _, executor = init_executor(executor)
         status = executor.query_status(exec_id)
         logger.info("Job %s status is %s" % (job_id, status))
@@ -105,7 +96,7 @@ def terminate_job(job_id: str, executor: Optional[dict] = None):
     """
     trace_id, exec_id = job_id.split("/")
     with set_directory(trace_id):
-        executor = load_executor(executor)
+        executor = load_job_info()["executor"] or executor
         _, executor = init_executor(executor)
         executor.terminate(exec_id)
         logger.info("Job %s is terminated" % job_id)
@@ -133,6 +124,69 @@ def handle_input_artifacts(fn, kwargs, storage):
                 "storage_type": scheme,
                 "uri": uri,
             }
+        elif param.annotation is List[Path] or (
+            param.annotation is Optional[List[Path]] and
+                kwargs.get(name) is not None):
+            uris = kwargs[name]
+            new_paths = []
+            for uri in uris:
+                scheme, key = parse_uri(uri)
+                if scheme == storage_type:
+                    s = storage
+                else:
+                    s = storage_dict[scheme]()
+                path = s.download(key, "inputs/%s" % name)
+                new_paths.append(Path(path))
+                logger.info("Artifact %s downloaded to %s" % (
+                    uri, path))
+            kwargs[name] = new_paths
+            input_artifacts[name] = {
+                "storage_type": storage_type,
+                "uri": uris,
+            }
+        elif param.annotation is Dict[str, Path] or (
+            param.annotation is Optional[Dict[str, Path]] and
+                kwargs.get(name) is not None):
+            uris_dict = kwargs[name]
+            new_paths_dict = {}
+            for key_name, uri in uris_dict.items():
+                scheme, key = parse_uri(uri)
+                if scheme == storage_type:
+                    s = storage
+                else:
+                    s = storage_dict[scheme]()
+                path = s.download(key, f"inputs/{name}/{key_name}")
+                new_paths_dict[key_name] = Path(path)
+                logger.info("Artifact %s (key=%s) downloaded to %s" % (
+                    uri, key_name, path))
+            kwargs[name] = new_paths_dict
+            input_artifacts[name] = {
+                "storage_type": storage_type,
+                "uri": uris_dict,
+            }
+        elif param.annotation is Dict[str, List[Path]] or (
+            param.annotation is Optional[Dict[str, List[Path]]] and
+                kwargs.get(name) is not None):
+            uris_dict = kwargs[name]
+            new_paths_dict = {}
+            for key_name, uris in uris_dict.items():
+                new_paths = []
+                for uri in uris:
+                    scheme, key = parse_uri(uri)
+                    if scheme == storage_type:
+                        s = storage
+                    else:
+                        s = storage_dict[scheme]()
+                    path = s.download(key, f"inputs/{name}/{key_name}")
+                    new_paths.append(Path(path))
+                    logger.info("Artifact %s (key=%s) downloaded to %s" % (
+                        uri, key_name, path))
+                new_paths_dict[key_name] = new_paths
+            kwargs[name] = new_paths_dict
+            input_artifacts[name] = {
+                "storage_type": storage_type,
+                "uri": uris_dict,
+            }
     return kwargs, input_artifacts
 
 
@@ -152,13 +206,28 @@ def handle_output_artifacts(results, exec_id, storage):
                     "storage_type": storage_type,
                     "uri": uri,
                 }
+            elif isinstance(results[name], list) and all(
+                    isinstance(item, Path) for item in results[name]):
+                new_uris = []
+                for item in results[name]:
+                    key = storage.upload("%s/outputs/%s" % (exec_id, name),
+                                         item)
+                    uri = storage_type + "://" + key
+                    logger.info("Artifact %s uploaded to %s" % (
+                        item, uri))
+                    new_uris.append(uri)
+                results[name] = new_uris
+                output_artifacts[name] = {
+                    "storage_type": storage_type,
+                    "uri": new_uris,
+                }
     return results, output_artifacts
 
 
 # MCP does not regard Any as serializable in Python 3.12
 # use Optional[Any] to work around
 def get_job_results(job_id: str, executor: Optional[dict] = None,
-                    storage: Optional[dict] = None) -> Optional[Any]:
+                    storage: Optional[dict] = None):
     """
     Get results of a calculation job
     Args:
@@ -168,8 +237,9 @@ def get_job_results(job_id: str, executor: Optional[dict] = None,
     """
     trace_id, exec_id = job_id.split("/")
     with set_directory(trace_id):
-        executor = load_executor(executor)
-        storage = load_storage(storage)
+        job_info = load_job_info()
+        executor = job_info["executor"] or executor
+        storage = job_info["storage"] or storage
         _, executor = init_executor(executor)
         results = executor.get_results(exec_id)
         results, output_artifacts = handle_output_artifacts(
@@ -177,7 +247,24 @@ def get_job_results(job_id: str, executor: Optional[dict] = None,
         logger.info("Job %s result is %s" % (job_id, results))
     return JobResult(result=results, job_info={
         "output_artifacts": output_artifacts,
-    })
+    }, tool_name=job_info["tool_name"])
+
+
+annotation_map = {
+    Path: str,
+    Optional[Path]: Optional[str],
+    List[Path]: List[str],
+    Optional[List[Path]]: Optional[List[str]],
+    Dict[str, Path]: Dict[str, str],
+    Optional[Dict[str, Path]]: Optional[Dict[str, str]],
+    Dict[str, List[Path]]: Dict[str, List[str]],
+    Optional[Dict[str, List[Path]]]: Optional[Dict[str, List[str]]],
+}
+
+
+class SubmitResult(BaseModel):
+    job_id: str
+    extra_info: dict | None = None
 
 
 class CalculationMCPServer:
@@ -191,47 +278,47 @@ class CalculationMCPServer:
         self.preprocess_func = preprocess_func
         self.fastmcp_mode = fastmcp_mode
         self.mcp = FastMCP(*args, **kwargs)
+        self.fn_metadata_map = {}
 
     def add_patched_tool(self, fn, new_fn, name, is_async=False, doc=None,
                          override_return_annotation=False):
         """patch the metadata of the tool"""
         context_kwarg = find_context_parameter(fn)
-
-        def _get_typed_signature_patched(call):
-            """patch parameters"""
-            typed_signature = _get_typed_signature(call)
-            new_typed_signature = _get_typed_signature(new_fn)
-            parameters = []
-            for param in typed_signature.parameters.values():
-                if param.annotation is Path:
-                    parameters.append(inspect.Parameter(
-                        name=param.name, default=param.default,
-                        annotation=str, kind=param.kind))
-                elif param.annotation is Optional[Path]:
-                    parameters.append(inspect.Parameter(
-                        name=param.name, default=param.default,
-                        annotation=Optional[str], kind=param.kind))
-                else:
-                    parameters.append(param)
-            for param in new_typed_signature.parameters.values():
-                if param.name != "kwargs":
-                    parameters.append(param)
-            return inspect.Signature(
-                parameters,
-                return_annotation=(new_typed_signature.return_annotation
-                                   if override_return_annotation
-                                   else typed_signature.return_annotation))
-
-        # Due to the frequent changes of MCP, we use a patching style here
-        mcp.server.fastmcp.utilities.func_metadata._get_typed_signature = \
-            _get_typed_signature_patched
         func_arg_metadata = func_metadata(
             fn,
             skip_names=[context_kwarg] if context_kwarg is not None else [],
-            structured_output=None,
         )
-        mcp.server.fastmcp.utilities.func_metadata._get_typed_signature = \
-            _get_typed_signature
+        self.fn_metadata_map[name] = func_arg_metadata
+        model_params = {}
+        params = inspect.signature(fn, eval_str=True).parameters
+        for n, annotation in \
+                func_arg_metadata.arg_model.__annotations__.items():
+            param = params[n]
+            if param.annotation in annotation_map:
+                model_params[n] = Annotated[
+                    (annotation_map[param.annotation], Field())]
+            else:
+                model_params[n] = annotation
+            if param.default is not inspect.Parameter.empty:
+                model_params[n] = (model_params[n], param.default)
+        for n, param in inspect.signature(new_fn).parameters.items():
+            if n == "kwargs":
+                continue
+            model_params[n] = Annotated[(param.annotation, Field())]
+            if param.default is not inspect.Parameter.empty:
+                model_params[n] = (model_params[n], param.default)
+
+        func_arg_metadata.arg_model = create_model(
+            f"{fn.__name__}Arguments",
+            __base__=ArgModelBase,
+            **model_params,
+        )
+        if override_return_annotation:
+            new_func_arg_metadata = func_metadata(new_fn)
+            func_arg_metadata.output_model = new_func_arg_metadata.output_model
+            func_arg_metadata.output_schema = \
+                new_func_arg_metadata.output_schema
+            func_arg_metadata.wrap_output = new_func_arg_metadata.wrap_output
         if self.fastmcp_mode and func_arg_metadata.wrap_output:
             # Only simulate behavior of fastmcp for output_schema
             func_arg_metadata.output_schema["x-fastmcp-wrap-result"] = True
@@ -240,16 +327,18 @@ class CalculationMCPServer:
         tool = Tool(
             fn=new_fn,
             name=name,
-            description=doc or fn.__doc__,
+            description=doc or fn.__doc__ or "",
             parameters=parameters,
             fn_metadata=func_arg_metadata,
             is_async=is_async,
             context_kwarg=context_kwarg,
+            fn_metadata_map=self.fn_metadata_map,
         )
         self.mcp._tool_manager._tools[name] = tool
 
     def add_tool(self, fn, *args, **kwargs):
-        tool = Tool.from_function(fn, *args, **kwargs)
+        tool = Tool.from_function(
+            fn, *args, fn_metadata_map=self.fn_metadata_map, **kwargs)
         self.mcp._tool_manager._tools[tool.name] = tool
         return tool
 
@@ -260,20 +349,20 @@ class CalculationMCPServer:
         def decorator(fn: Callable) -> Callable:
             def submit_job(executor: Optional[dict] = None,
                            storage: Optional[dict] = None,
-                           **kwargs) -> TypedDict("results", {
-                               "job_id": str, "extra_info": Optional[dict]}):
+                           **kwargs) -> SubmitResult:
                 trace_id = datetime.today().strftime('%Y-%m-%d-%H:%M:%S.%f')
                 logger.info("Job processing (Trace ID: %s)" % trace_id)
                 with set_directory(trace_id):
                     if preprocess_func is not None:
                         executor, storage, kwargs = preprocess_func(
                             executor, storage, kwargs)
-                    if executor:
-                        with open("executor.json", "w") as f:
-                            json.dump(executor, f, indent=4)
-                    if storage:
-                        with open("storage.json", "w") as f:
-                            json.dump(storage, f, indent=4)
+                    job = {
+                        "tool_name": fn.__name__,
+                        "executor": executor,
+                        "storage": storage,
+                    }
+                    with open("job.json", "w") as f:
+                        json.dump(job, f, indent=4)
                     kwargs, input_artifacts = handle_input_artifacts(
                         fn, kwargs, storage)
                     executor_type, executor = init_executor(executor)
@@ -281,10 +370,10 @@ class CalculationMCPServer:
                     exec_id = res["job_id"]
                     job_id = "%s/%s" % (trace_id, exec_id)
                     logger.info("Job submitted (ID: %s)" % job_id)
-                result = {
-                    "job_id": job_id,
-                    "extra_info": res.get("extra_info"),
-                }
+                result = SubmitResult(
+                    job_id=job_id,
+                    extra_info=res.get("extra_info"),
+                )
                 return JobResult(result=result, job_info={
                     "trace_id": trace_id,
                     "executor_type": executor_type,

{bohr_agent_sdk-0.1.110 → bohr_agent_sdk-0.1.112}/src/dp/agent/server/executor/dispatcher_executor.py

@@ -135,7 +135,7 @@ class DispatcherExecutor(BaseExecutor):
         func_def_script, packages = get_func_def_script(fn)
         self.python_packages.extend(packages)
 
-        script += "import asyncio, jsonpickle, os\n"
+        script += "import asyncio, jsonpickle, os, shutil\n"
         script += "from pathlib import Path\n\n"
         script += "if __name__ == \"__main__\":\n"
         script += "    cwd = os.getcwd()\n"
@@ -149,11 +149,24 @@ class DispatcherExecutor(BaseExecutor):
             script += "        results = asyncio.run(%s(**kwargs))\n" % fn_name
         else:
             script += "        results = %s(**kwargs)\n" % fn_name
+            script += "        result_dir = None\n"
+            script += "        import uuid\n"
             script += "        if isinstance(results, dict):\n"
             script += "            for name in results:\n"
             script += "                if isinstance(results[name], Path):\n"
-            script += "                    results[name] = " \
-                      "results[name].absolute().relative_to(cwd)\n"
+            script += "                    if not results[name].absolute().is_relative_to(cwd):\n"
+            script += "                        if result_dir is None:\n"
+            script += "                            result_dir = Path('result_files_dir_' + str(uuid.uuid4()))\n"
+            script += "                            result_dir.mkdir(parents=True, exist_ok=True)\n"
+            script += "                        dest_path = result_dir / results[name].absolute().relative_to('/')\n"
+            script += "                        dest_path.parent.mkdir(parents=True, exist_ok=True)\n"
+            script += "                        if results[name].is_file():\n"
+            script += "                            shutil.copy2(results[name], dest_path)\n"
+            script += "                        elif results[name].is_dir():\n"
+            script += "                            shutil.copytree(results[name], dest_path, dirs_exist_ok=True)\n"
+            script += "                        results[name] = dest_path.absolute().relative_to(cwd)\n"
+            script += "                    else:\n"
+            script += "                        results[name] = results[name].absolute().relative_to(cwd)\n"
         script += "    except Exception as e:\n"
         script += "        os.chdir(cwd)\n"
         script += "        with open('err', 'w') as f:\n"

{bohr_agent_sdk-0.1.110 → bohr_agent_sdk-0.1.112}/src/dp/agent/server/utils.py

@@ -21,6 +21,7 @@ def get_logger(name, level="INFO",
 class JobResult(BaseModel):
     result: Any
     job_info: dict
+    tool_name: str | None = None
 
 
 class Tool(mcp.server.fastmcp.tools.Tool):
@@ -28,13 +29,23 @@ class Tool(mcp.server.fastmcp.tools.Tool):
     Workaround MCP server cannot print traceback
     Add job info to first unstructured content
     """
+    fn_metadata_map: dict | None = None
+
+    @classmethod
+    def from_function(cls, *args, fn_metadata_map=None, **kwargs):
+        tool = super().from_function(*args, **kwargs)
+        tool.fn_metadata_map = fn_metadata_map
+        return tool
+
     async def run(self, *args, **kwargs):
         try:
             kwargs["convert_result"] = False
             result = await super().run(*args, **kwargs)
             if isinstance(result, JobResult):
                 job_info = result.job_info
-                result = self.fn_metadata.convert_result(result.result)
+                fn_metadata = self.fn_metadata_map.get(
+                    result.tool_name, self.fn_metadata)
+                result = fn_metadata.convert_result(result.result)
                 if isinstance(result, tuple) and len(result) == 2:
                     unstructured_content, _ = result
                 else: