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

hyperpocket/tool/function/tool.py

@@ -1,6 +1,8 @@
+import asyncio
 import copy
 import inspect
-from typing import Callable, Awaitable, Optional
+from typing import Any, Coroutine
+from typing import Callable, Optional
 
 from pydantic import BaseModel
 
@@ -13,49 +15,67 @@ 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)
 
         # make body args to model
-        schema_model = self.schema_model()
-        model = schema_model(body=_kwargs["body"])
+        schema_model = self.schema_model(use_profile=False)
+        model = schema_model(**_kwargs["body"])
         _kwargs.pop("body")
 
         # body model to dict
-        args = self.model_to_kwargs(model.body)
+        args = self.model_to_kwargs(model)
 
         # binding args
         binding_args = {}
-        sig = inspect.signature(self.func)
-        for param_name, param in sig.parameters.items():
-            if param_name not in args:
-                continue
+        if self.func.__dict__.get("__model__") is not None:
+            # when a function signature is not inferrable from the function itself
+            binding_args = args.copy()
+            binding_args |= _kwargs.get("envs", {}) | self.tool_vars
+        else:
+            sig = inspect.signature(self.func)
+            for param_name, param in sig.parameters.items():
+                if param_name not in args:
+                    continue
 
-            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", {})
+                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", {}) | self.tool_vars
 
-                if "envs" in _kwargs:
-                    _kwargs.pop("envs")
+                    if "envs" in _kwargs:
+                        _kwargs.pop("envs")
 
-                binding_args |= _kwargs  # add other kwargs
-                continue
+                    binding_args |= _kwargs  # add other kwargs
+                    continue
 
-            binding_args[param_name] = args[param_name]
+                binding_args[param_name] = args[param_name]
 
         return binding_args
 
@@ -69,11 +89,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())
 
@@ -81,7 +116,51 @@ class FunctionTool(Tool):
             func=func,
             afunc=afunc,
             name=func.__name__,
-            description=model.__doc__,
+            description=func.__doc__ if func.__doc__ is not None else "",
             argument_json_schema=argument_json_schema,
-            auth=auth
+            auth=auth,
+            default_tool_vars=tool_vars
         )
+    
+    @classmethod
+    def from_dock(
+        cls,
+        dock: list[Callable[..., str]],
+        tool_vars: Optional[dict[str, str]] = None,
+    ) -> list["FunctionTool"]:
+        if tool_vars is None:
+            tool_vars = dict()
+        tools = []
+        for func in dock:
+            if (_model := func.__dict__.get("__model__")) is not None:
+                model = _model
+            else:
+                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,
+                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
+                ))
+            else:
+                tools.append(cls(
+                    func=func,
+                    afunc=None,
+                    name=func.__name__,
+                    description=func.__doc__,
+                    argument_json_schema=argument_json_schema,
+                    auth=auth,
+                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
+                ))
+        return tools

hyperpocket/tool/tool.py

@@ -1,10 +1,11 @@
 import abc
-from typing import TypeVar, Optional, Type
+from typing import Optional, Type, Callable
 
 from pydantic import BaseModel, Field
 
 from hyperpocket.auth.provider import AuthProvider
 from hyperpocket.config.logger import pocket_logger
+from hyperpocket.prompts import pocket_extended_tool_description
 from hyperpocket.util.json_schema_to_model import json_schema_to_model
 
 
@@ -27,10 +28,34 @@ 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 +65,11 @@ 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")
+    use_profile: bool = False
 
     @abc.abstractmethod
     def invoke(self, **kwargs) -> str:
@@ -54,12 +84,26 @@ class Tool(BaseModel, abc.ABC):
         """
         raise NotImplementedError()
 
-    def schema_model(self) -> Optional[Type[BaseModel]]:
+    def schema_model(self, use_profile: bool = False) -> Optional[Type[BaseModel]]:
         """
         Returns a schema_model that wraps the existing argument_json_schema
         to include profile and thread_id as arguments when the tool is invoked
         """
-        return self._get_schema_model(self.name, self.argument_json_schema)
+        return self._get_schema_model(self.name, self.argument_json_schema, use_profile=use_profile)
+
+    def get_description(self, use_profile: bool = False) -> str:
+        if use_profile:
+            return pocket_extended_tool_description(self.description)
+        else:
+            return self.description
+
+    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':
@@ -69,38 +113,66 @@ class Tool(BaseModel, abc.ABC):
         raise ValueError('Unknown tool request type')
 
     @classmethod
-    def _get_schema_model(cls, name: str, json_schema: Optional[dict]) -> Optional[Type[BaseModel]]:
+    def _get_schema_model(cls, name: str, json_schema: Optional[dict], use_profile: bool) -> Optional[Type[BaseModel]]:
         try:
             if not json_schema:
                 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.'
-            extended_schema = {
-                'title': name,
-                'type': 'object',
-                'properties': {
-                    'thread_id': {
-                        'type': 'string',
-                        'default': 'default',
-                        'description': 'The ID of the chat thread where the tool is invoked. Omitted when unknown.',
-                    },
-                    'profile': {
-                        'type': 'string',
-                        'default': 'default',
-                        'description': '''The profile of the user invoking the tool. Inferred from user's messages.
-                        Users can request tools to be invoked in specific personas, which is called a profile.
-                        If the user's profile name can be inferred from the query, pass it as a string in the 'profile'
-                        JSON property. Omitted when unknown.''',
+                json_schema['description'] = 'The argument of the tool.'
+
+            if use_profile:
+                json_schema = {
+                    'title': name,
+                    'type': 'object',
+                    'properties': {
+                        'thread_id': {
+                            'type': 'string',
+                            'default': 'default',
+                            'description': 'The ID of the chat thread where the tool is invoked. Omitted when unknown.',
+                        },
+                        'profile': {
+                            'type': 'string',
+                            'default': 'default',
+                            'description': '''The profile of the user invoking the tool. Inferred from user's messages.
+                            Users can request tools to be invoked in specific personas, which is called a profile.
+                            If the user's profile name can be inferred from the query, pass it as a string in the 'profile'
+                            JSON property. Omitted when unknown.''',
+                        },
+                        'body': json_schema
                     },
-                    'body': json_schema
-                },
-                'required': [
-                    'body',
-                ]
-            }
-            model = json_schema_to_model(extended_schema, name)
+                    'required': [
+                        'body',
+                    ]
+                }
+
+            model = json_schema_to_model(json_schema, name)
             return model
         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/browser.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 
 from playwright.async_api import async_playwright, Page, Playwright, BrowserContext, Route
 
@@ -13,15 +14,9 @@ class InvokerBrowser(object):
         raise RuntimeError("Use InvokerBrowser.get_instance() instead")
 
     async def _async_init(self):
-        # false only in dev
-        # TODO(moon.dev) : load from config by environment
-        import os
-        pocket_env = os.getenv("POCKET_ENV", "DEVELOPMENT")
-        is_headless = False if pocket_env == "DEVELOPMENT" else True
-
         self.playwright = await async_playwright().start()
         self.browser_context = await self.playwright.chromium.launch_persistent_context(
-            headless=is_headless,
+            headless=True,
             args=[
                 '--disable-web-security=True',
             ],

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>