hyperpocket 0.0.3__py3-none-any.whl → 0.1.8__py3-none-any.whl

hyperpocket/tool/function/tool.py

@@ -1,7 +1,11 @@
+import asyncio
 import copy
 import inspect
-from typing import Callable, Awaitable, Optional
+import pathlib
+from typing import Any, Coroutine
+from typing import Callable, Optional
 
+import toml
 from pydantic import BaseModel
 
 from hyperpocket.tool.tool import Tool, ToolAuth
@@ -13,18 +17,31 @@ class FunctionTool(Tool):
     """
     FunctionTool is Tool executing local python method.
     """
-    func: Callable
-    afunc: Optional[Callable[..., Awaitable[str]]]
+    func: Optional[Callable[..., str]]
+    afunc: Optional[Callable[..., Coroutine[Any, Any, str]]]
 
     def invoke(self, **kwargs) -> str:
         binding_args = self._get_binding_args(kwargs)
-        return str(self.func(**binding_args))
+        if self.func is None:
+            if self.afunc is None:
+                raise ValueError("Both func and afunc are None")
+            try:
+                return str(asyncio.run(self.afunc(**binding_args)))
+            except Exception as e:
+                return "There was an error while executing the tool: " + str(e)
+        try:
+            return str(self.func(**binding_args))
+        except Exception as e:
+            return "There was an error while executing the tool: " + str(e)
 
     async def ainvoke(self, **kwargs) -> str:
-        binding_args = self._get_binding_args(kwargs)
         if self.afunc is None:
-            return str(self.func(**binding_args))
-        return str(await self.afunc(**binding_args))
+            return str(self.invoke(**kwargs))
+        try:
+            binding_args = self._get_binding_args(kwargs)
+            return str(await self.afunc(**binding_args))
+        except Exception as e:
+            return "There was an error while executing the tool: " + str(e)
 
     def _get_binding_args(self, kwargs):
         _kwargs = copy.deepcopy(kwargs)
@@ -47,7 +64,7 @@ class FunctionTool(Tool):
             if param.kind == param.VAR_KEYWORD:
                 # var keyword args should be passed by plain dict
                 binding_args |= args[param_name]
-                binding_args |= _kwargs.get("envs", {})
+                binding_args |= _kwargs.get("envs", {}) | self.tool_vars
 
                 if "envs" in _kwargs:
                     _kwargs.pop("envs")
@@ -69,11 +86,26 @@ class FunctionTool(Tool):
 
     @classmethod
     def from_func(
-            cls,
-            func: Callable,
-            afunc: Callable[..., Awaitable[str]] = None,
-            auth: Optional[ToolAuth] = None
+        cls,
+        func: Callable | 'FunctionTool',
+        afunc: Callable[..., Coroutine[Any, Any, str]] | 'FunctionTool' = None,
+        auth: Optional[ToolAuth] = None,
+        tool_vars: dict[str, str] = None,
     ) -> "FunctionTool":
+        if tool_vars is None:
+            tool_vars = dict()
+            
+        if isinstance(func, FunctionTool):
+            if tool_vars is not None:
+                func.override_tool_variables(tool_vars)
+            return func
+        elif isinstance(afunc, FunctionTool):
+            if tool_vars is not None:
+                afunc.override_tool_variables(tool_vars)
+            return afunc
+        elif not callable(func) and not callable(afunc):
+            raise ValueError("FunctionTool can only be created from a callable")
+        
         model = function_to_model(func)
         argument_json_schema = flatten_json_schema(model.model_json_schema())
 
@@ -83,5 +115,58 @@ class FunctionTool(Tool):
             name=func.__name__,
             description=model.__doc__,
             argument_json_schema=argument_json_schema,
-            auth=auth
+            auth=auth,
+            default_tool_vars=tool_vars
         )
+    
+    @classmethod
+    def from_dock(
+        cls,
+        dock: list[Callable[..., str]],
+    ) -> list["FunctionTool"]:
+        tools = []
+        for func in dock:
+            model = function_to_model(func)
+            argument_json_schema = flatten_json_schema(model.model_json_schema())
+            if not callable(func):
+                raise ValueError(f"Dock element should be a list of functions, but found {func}")
+            is_coroutine = inspect.iscoroutinefunction(func)
+            auth = None
+            if func.__dict__.get("__auth__") is not None:
+                auth = ToolAuth(**func.__dict__["__auth__"])
+            if is_coroutine:
+                tools.append(cls(
+                    func=None,
+                    afunc=func,
+                    name=func.__name__,
+                    description=func.__doc__,
+                    argument_json_schema=argument_json_schema,
+                    auth=auth,
+                ))
+            else:
+                tools.append(cls(
+                    func=func,
+                    afunc=None,
+                    name=func.__name__,
+                    description=func.__doc__,
+                    argument_json_schema=argument_json_schema,
+                    auth=auth,
+                ))
+        return tools
+        
+    @classmethod
+    def _get_tool_vars_from_config(cls, func: Callable) -> dict:
+        print(func.__name__)
+        tool_path = inspect.getfile(func)
+        print(tool_path)
+        tool_parent = "/".join(tool_path.split("/")[:-1])
+        tool_config_path = pathlib.Path(tool_parent) / "config.toml"
+        with tool_config_path.open("r") as f:
+            tool_config = toml.load(f)
+            tool_vars = tool_config.get("tool_var")
+            if not tool_vars:
+                return 
+            tool_vars_dict = {}
+            for key, value in tool_vars.items():
+                tool_vars_dict[key] = value
+            return tool_vars_dict

hyperpocket/tool/tests/test_function_tool.py

@@ -29,6 +29,61 @@ class TestFunctionTool(TestCase):
 
         # then
         self.assertEqual(result, '3')
+    
+    def test_function_tool_variables(self):
+        @function_tool(
+            tool_vars={
+                'a': '1',
+                'b': '2',
+            },
+        )
+        def always_three(**kwargs):
+            a = int(kwargs['a'])
+            b = int(kwargs['b'])
+            return str(a+b)
+        
+        result = always_three.invoke(
+            body={}
+        )
+        self.assertEqual(result, '3')
+
+    def test_function_tool_overridden_variables(self):
+        @function_tool(
+            tool_vars={
+                'a': '1',
+                'b': '1',
+            },
+        )
+        def always_two(**kwargs):
+            a = int(kwargs['a'])
+            b = int(kwargs['b'])
+            return str(a+b)
+        
+        always_two.override_tool_variables({
+            'a': '1',
+            'b': '2',
+        })
+        result = always_two.invoke(body={})
+        self.assertEqual(result, '3')
+    
+    def test_function_tool_overridden_variables_from_func(self):
+        @function_tool(
+            tool_vars={
+                'a': '1',
+                'b': '1',
+            },
+        )
+        def always_two(**kwargs):
+            a = int(kwargs['a'])
+            b = int(kwargs['b'])
+            return str(a+b)
+        
+        tool = FunctionTool.from_func(always_two, tool_vars={
+            "a": "1",
+            "b": "2",
+        })
+        result = tool.invoke(body={})
+        self.assertEqual(result, '3')
 
     def test_pydantic_input_function_tool_call(self):
         # given

hyperpocket/tool/tests/test_wasm_tool.py

@@ -0,0 +1,73 @@
+import pathlib
+from tempfile import TemporaryDirectory
+from unittest import TestCase
+
+from hyperpocket.repository import Lockfile
+from hyperpocket.tool import from_local
+from hyperpocket.tool.wasm import WasmTool
+from hyperpocket.tool.wasm.invoker import WasmInvoker
+
+
+class TestWasmTool(TestCase):
+
+    class MockInvoker(WasmInvoker):
+        def invoke(self, tool_path, runtime, body, envs, **kwargs):
+            return str(int(envs["a"]) + int(envs["b"]))
+        async def ainvoke(self, tool_path, runtime, body, envs, **kwargs):
+            return str(int(envs["a"]) + int(envs["b"]))
+
+    def test_wasm_tool_vars_inject(self):
+        with TemporaryDirectory() as tool_dir:
+            with open(f"{tool_dir}/schema.json", "w") as f:
+                f.write("{}")
+            with open(f"{tool_dir}/config.toml", "w") as f:
+                f.write("""
+name = "mock"
+description = "mock"
+language = "python"
+
+[tool_vars]
+a = "1"
+b = "2"
+""")
+            with open(f"{tool_dir}/README.md", "w") as f:
+                f.write("mock")
+            lockfile = Lockfile(pathlib.Path(tool_dir) / ".lock")
+            req = from_local(tool_dir)
+            lockfile.add_lock(req.lock)
+            lockfile.sync(False)
+            tool = WasmTool.from_tool_request(req, lockfile=lockfile)
+            tool._invoker = self.MockInvoker()
+            tool.override_tool_variables({
+                "a": "1",
+                "b": "1"
+            })
+            self.assertEqual(tool.invoke(body={}, envs={}), "2")
+
+    def test_wasm_tool_vars_inject_with_from_local(self):
+        with TemporaryDirectory() as tool_dir:
+            with open(f"{tool_dir}/schema.json", "w") as f:
+                f.write("{}")
+            with open(f"{tool_dir}/config.toml", "w") as f:
+                f.write("""
+name = "mock"
+description = "mock"
+language = "python"
+
+[tool_vars]
+a = "1"
+b = "2"
+""")
+            with open(f"{tool_dir}/README.md", "w") as f:
+                f.write("mock")
+            lockfile = Lockfile(pathlib.Path(tool_dir) / ".lock")
+            req = from_local(tool_dir, tool_vars={
+                "a": "1",
+                "b": "1"
+            })
+            lockfile.add_lock(req.lock)
+            lockfile.sync(False)
+            tool = WasmTool.from_tool_request(req, lockfile=lockfile)
+            tool._invoker = self.MockInvoker()
+            self.assertEqual(tool.invoke(body={}, envs={}), "2")
+            

hyperpocket/tool/tool.py

@@ -1,5 +1,8 @@
 import abc
-from typing import TypeVar, Optional, Type
+import pathlib
+
+import toml
+from typing import Optional, Type, Callable
 
 from pydantic import BaseModel, Field
 
@@ -27,9 +30,33 @@ class ToolAuth(BaseModel):
 
 
 class ToolRequest(abc.ABC):
+    postprocessings: Optional[list[Callable]] = None
+    overridden_tool_vars: dict[str, str] = Field(default_factory=dict, description="overridden tool variables")
+
     @abc.abstractmethod
     def __str__(self):
         raise NotImplementedError
+    
+    def add_postprocessing(self, postprocessing: Callable):
+        if self.postprocessings is None:
+            self.postprocessings = [postprocessing]
+        else:
+            self.postprocessings.append(postprocessing)
+
+    def __or__(self, other: Callable):
+        self.add_postprocessing(other)
+        return self
+
+    def with_postprocessings(self, postprocessings: list[Callable]):
+        if self.postprocessings is None:
+            self.postprocessings = postprocessings
+        else:
+            self.postprocessings.extend(postprocessings)
+        return self
+
+    def override_tool_variables(self, override_vars: dict[str, str]) -> 'ToolRequest':
+        self.overridden_tool_vars = override_vars
+        return self
 
 
 class Tool(BaseModel, abc.ABC):
@@ -40,6 +67,9 @@ class Tool(BaseModel, abc.ABC):
     description: str = Field(description="tool description")
     argument_json_schema: Optional[dict] = Field(default=None, description="tool argument json schema")
     auth: Optional[ToolAuth] = Field(default=None, description="authentication information to invoke tool")
+    postprocessings: Optional[list[Callable]] = Field(default=None, description="postprocessing functions after tool is invoked")
+    default_tool_vars: dict[str, str] = Field(default_factory=dict, description="default tool variables")
+    overridden_tool_vars: dict[str, str] = Field(default_factory=dict, description="overridden tool variables")
 
     @abc.abstractmethod
     def invoke(self, **kwargs) -> str:
@@ -60,6 +90,14 @@ class Tool(BaseModel, abc.ABC):
         to include profile and thread_id as arguments when the tool is invoked
         """
         return self._get_schema_model(self.name, self.argument_json_schema)
+    
+    def override_tool_variables(self, override_vars: dict[str, str]) -> 'Tool':
+        self.overridden_tool_vars = override_vars
+        return self
+    
+    @property
+    def tool_vars(self) -> dict[str, str]:
+        return self.default_tool_vars | self.overridden_tool_vars
 
     @classmethod
     def from_tool_request(cls, tool_req: ToolRequest, **kwargs) -> 'Tool':
@@ -75,7 +113,7 @@ class Tool(BaseModel, abc.ABC):
                 pocket_logger.info(f"{name} tool's json_schema is none.")
                 return None
             if 'description' not in json_schema:
-                json_schema['description'] = f'The argument of the tool.'
+                json_schema['description'] = 'The argument of the tool.'
             extended_schema = {
                 'title': name,
                 'type': 'object',
@@ -104,3 +142,28 @@ class Tool(BaseModel, abc.ABC):
         except Exception as e:
             pocket_logger.warning(f"failed to get tool({name}) schema model. error : {e}")
             pass
+
+    def with_postprocessing(self, postprocessing: Callable):
+        """
+        Add a postprocessing function to the tool
+        """
+        if self.postprocessings is None:
+            self.postprocessings = [postprocessing]
+        else:
+            self.postprocessings.append(postprocessing)
+        return self
+
+    def __or__(self, other: Callable):
+        self.with_postprocessing(other)
+        return self
+
+    def with_postprocessings(self, postprocessings: list[Callable]):
+        """
+        Add a list of postprocessing functions to the tool
+        Returns the tool itself
+        """
+        if self.postprocessings is None:
+            self.postprocessings = postprocessings
+        else:
+            self.postprocessings.extend(postprocessings)
+        return self

hyperpocket/tool/wasm/README.md

@@ -52,7 +52,6 @@ WasmToolRequest offer those build method:
 
 - `from_local`
 - `from_git`
-- `from_github`
 
 Each `WasmToolRequest` has it's own `Lock` object
 
@@ -98,6 +97,29 @@ classDiagram
     Lockfile o-- Pocket : 1..1
 ```
 
+### Inject tool variables
+
+If the user specifies [tool_vars] in the `config.toml` of the tool's repository, which is allowed to be injected dynamically when the user develops an agent, it can be injected through the following steps.
+
+```toml
+# config.toml of a tool
+
+[tool_vars]
+config1 = "config1"
+config2 = "config2"
+```
+
+1. Injecting tool_vars when importing tool in code.
+
+```python
+from_git('https://github.com/your-organization/your-repository/tree/main',tool_vars = {
+    "config1": "modified_config1"
+})
+```
+
+2. Injecting envvars by settings.toml
+   If there are remaining envvars, Hyperpocket checks the `settings.toml` from the agent code directory.
+
 ## WasmTool
 
 ```python
@@ -112,11 +134,11 @@ class WasmTool(Tool):
 
 - `_invoker`: A class for executing WASM.
 - `pkg_lock`: The lock class for the tool.
-    - Used to determine the package path where the current WASM code is stored.
+- Used for determining the package path where the current WASM code is stored.
 - `rel_path`: The relative path to the location of the WASM code within the package.
 - `runtime`: The runtime language of the WASM code.
 - `json_schema`: The JSON schema for the WASM tool.
-    - Information read from schema.json.
+- Information read from schema.json.
 - `readme`: The README information.
 
 ## WasmInvoker
@@ -134,11 +156,11 @@ sequenceDiagram
     participant WasmTool as WasmTool (Includes Server)
     participant Browser as Browser (Executes WASM Runtime)
 
-    
+
     WasmTool->>WasmTool: Render HTML and Store in Memory
     WasmTool->>Browser: Launch Browser
     Browser->>WasmTool: Request Rendered HTML
     WasmTool->>Browser: Provide Rendered HTML
     Browser->>Browser: Execute Injected WASM Runtime Script
     Browser->>WasmTool: Return Execution Result
-```
+```

hyperpocket/tool/wasm/script.py

@@ -3,8 +3,11 @@ import enum
 import pathlib
 from typing import Optional
 
+import toml
 from pydantic import BaseModel
 
+from hyperpocket.config import pocket_logger
+
 
 class ScriptRuntime(enum.Enum):
     Node = "node"
@@ -62,7 +65,43 @@ class Script(BaseModel):
                 encoded_str = encoded_bytes.decode()
                 file_tree = ScriptFileNode.merge(file_tree, ScriptFileNode.create_file_tree(p, encoded_str))
         return file_tree
-                
+    
+    @property
+    def package_name(self) -> Optional[str]:
+        if self.runtime != ScriptRuntime.Python:
+            return
+        pyproject = toml.load(pathlib.Path(self.tool_path) / "pyproject.toml")
+        if "project" in pyproject:
+            name = pyproject["project"]["name"]
+        if "tool" in pyproject and "poetry" in pyproject["tool"]:
+            name = pyproject["tool"]["poetry"]["name"]
+        if not name:
+            raise ValueError("Could not find package name")
+        return name.replace("-", "_")
+    
+    @property
+    def entrypoint(self) -> str:
+        pocket_logger.info(self.tool_path)
+        if self.runtime == ScriptRuntime.Node:
+            return "dist/index.js"
+        elif self.runtime == ScriptRuntime.Wasm:
+            return "dist/main.wasm"
+        pyproject = toml.load(pathlib.Path(self.tool_path) / "pyproject.toml")
+        version = None
+        if "project" in pyproject:
+            version = pyproject["project"]["version"]
+        elif "tool" in pyproject and "poetry" in pyproject["tool"]:
+            version = pyproject["tool"]["poetry"]["version"]
+        else:
+            raise ValueError("Could not find package version")
+        wheel_name = f"{self.package_name}-{version}-py3-none-any.whl"
+        wheel_path = pathlib.Path(self.tool_path) / "dist" / wheel_name
+        if not wheel_path.exists():
+            raise ValueError(f"Wheel file {wheel_path} does not exist")
+        return wheel_name
+    
+    def dist_file_path(self, file_name: str) -> str:
+        return str(pathlib.Path(self.tool_path) / "dist" / file_name)
 
 class _ScriptStore(object):
     scripts: dict[str, Script] = {}

hyperpocket/tool/wasm/templates/python.py

@@ -16,27 +16,24 @@ python_template = '''
             scriptID: `{{ SCRIPT_ID }}`
         }
     }
-    async function main() {
+    async function _main() {
+        // load the script configs
         loadConfig();
-        const b64FilesResp = await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/file_tree`);
-        const b64Files = await b64FilesResp.json();
-        const code = atob(b64Files.tree["main.py"].file.contents);
-        const requirements = atob(b64Files.tree["requirements.txt"].file.contents);
         
+        // get entrypoint wheel
+        const entrypointResp = await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/entrypoint`);
+        const { package_name: packageName, entrypoint } = await entrypointResp.json();
+        
+        // initialize pyodide
         const pyodide = await loadPyodide({
             env: JSON.parse(globalThis.toolConfigs.envs),
         });
         await pyodide.loadPackage("micropip");
         await pyodide.loadPackage("ssl");
         const micropip = pyodide.pyimport("micropip");
+        await micropip.install(entrypoint);
         await micropip.install("pyodide-http")
-        const installation = requirements.split("\\n").map(async (req) => {
-            if (req) {
-                const pkg = req.split("==")[0];
-                await micropip.install(pkg);
-            }
-        });
-        await Promise.all(installation);
+        
         let emitted = false;
         const decodedBytes = atob(globalThis.toolConfigs.body);
         pyodide.setStdin({
@@ -50,14 +47,19 @@ python_template = '''
             autoEOF: true,
         })
         let stdout = "";
+        let stderr = "";
         pyodide.setStdout({
             batched: (x) => { stdout += x; },
         })
+        pyodide.setStderr({
+            batched: (x) => { stderr += x; },
+        })
         await pyodide.runPythonAsync(`
 import pyodide_http
 pyodide_http.patch_all()
 
-${code}
+import ${packageName}
+${packageName}.main()
 `);
         console.log(stdout)
         await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/done`, {
@@ -65,9 +67,25 @@ ${code}
             headers: {
                 'Content-Type': 'application/json'
             },
-            body: JSON.stringify({ stdout })
+            body: JSON.stringify({ stdout, stderr })
         });
     }
+    
+    async function main() {
+        try {
+            await _main();
+        } catch (e) {
+            console.error(e);
+            await fetch(`/tools/wasm/scripts/${globalThis.toolConfigs.scriptID}/done`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ error: e.message })
+            });
+        }
+    }
+    
     main();
 </script>
 </body>