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

hyperpocket/config/settings.py

@@ -7,18 +7,22 @@ from pydantic import BaseModel, Field
 from hyperpocket.config.auth import AuthConfig, DefaultAuthConfig
 from hyperpocket.config.session import DefaultSessionConfig, SessionConfig
 
-pocket_root = Path.home() / ".pocket"
-if not pocket_root.exists():
-    os.makedirs(pocket_root)
-settings_path = pocket_root / "settings.toml"
+POCKET_ROOT = Path.home() / ".pocket"
+SETTING_ROOT = Path.cwd()
+
+
+settings_path = SETTING_ROOT / "settings.toml"
 if not settings_path.exists():
     with open(settings_path, "w"):
         pass
-secret_path = pocket_root / ".secrets.toml"
+
+secret_path = SETTING_ROOT / ".secrets.toml"
 if not secret_path.exists():
     with open(secret_path, "w"):
         pass
-toolpkg_path = pocket_root / "toolpkg"
+
+
+toolpkg_path = POCKET_ROOT / "toolpkg"
 if not toolpkg_path.exists():
     os.makedirs(toolpkg_path)
 
@@ -50,9 +54,9 @@ class Config(BaseModel):
 
     @property
     def public_base_url(self):
-        if self.public_server_protocol == 'https' and self.public_server_port == 443:
+        if self.public_server_protocol == "https" and self.public_server_port == 443:
             return f"{self.public_server_protocol}://{self.public_hostname}"
-        elif self.public_server_protocol == 'http' and self.public_server_port == 80:
+        elif self.public_server_protocol == "http" and self.public_server_port == 80:
             return f"{self.public_server_protocol}://{self.public_hostname}"
         return f"{self.public_server_protocol}://{self.public_hostname}:{self.public_server_port}"
 

hyperpocket/pocket_core.py

@@ -38,8 +38,10 @@ class PocketCore:
                     lock = LocalLock(tool_like)
                     req = WasmToolRequest(lock, "")
                 else:
-                    lock = GitLock(repository_url=tool_like, git_ref='HEAD')
-                    req = WasmToolRequest(lock, "")
+                    base_repo_url, git_ref, rel_path = GitLock.parse_repo_url(repo_url=tool_like)
+                    lock = GitLock(repository_url=base_repo_url, git_ref=git_ref)
+                    req = WasmToolRequest(lock=lock, rel_path=rel_path, tool_vars={})
+
                 lockfile.add_lock(lock)
                 tool_likes.append(req)
             elif isinstance(tool_like, WasmToolRequest):

hyperpocket/pocket_main.py

@@ -16,7 +16,9 @@ class Pocket(object):
                  tools: list[ToolLike],
                  auth: PocketAuth = None,
                  lockfile_path: Optional[str] = None,
-                 force_update: bool = False):
+                 force_update: bool = False,
+                 use_profile: bool = False):
+        self.use_profile = use_profile
 
         self.core = PocketCore(
             tools=tools,

hyperpocket/repository/lock.py

@@ -1,7 +1,7 @@
 import abc
 import pathlib
 import shutil
-from typing import Optional
+from typing import Optional, Tuple
 
 import git
 from pydantic import BaseModel, Field
@@ -159,6 +159,57 @@ class GitLock(Lock):
                 break
         return new_sha
 
+    @classmethod
+    def get_git_branches(cls, repo_url):
+        ls_lists = git.cmd.Git().ls_remote(repo_url)
+
+        branches = {}
+        for line in ls_lists.split("\n"):
+            sha, ref = line.split("\t")
+            if ref.startswith("refs/heads/"):
+                branch_name = ref.replace("refs/heads/", "")
+                branches[branch_name] = sha
+
+        return branches
+
+    @classmethod
+    def parse_repo_url(cls, repo_url: str) -> Tuple[str, str, str]:
+        """
+        Parses a GitHub repository URL with optional branch and path information.
+
+        Returns:
+            Tuple[str, str, str]: base_repo, branch_name, directory_path
+        """
+        if not repo_url.startswith("https://github.com/"):
+            raise AttributeError("Only GitHub URLs are supported")
+
+        # Remove the base URL and split the path
+        repo_path = repo_url.removeprefix("https://github.com/")
+        repo_path_list = repo_path.split("/")
+
+        # Check if the URL contains 'tree' (indicating branch and sub-path information)
+        if "tree" not in repo_path_list:
+            # If no 'tree', return the full repository URL
+            return repo_url, "HEAD", ""
+
+        # Parse base repo URL and remaining path
+        tree_index = repo_path_list.index("tree")
+        base_repo = f"https://github.com/{'/'.join(repo_path_list[:tree_index])}"
+        sub_path = repo_path_list[tree_index + 1:]
+
+        # Fetch branch information
+        branches = cls.get_git_branches(base_repo)
+
+        # Find branch and sub-directory path
+        for idx in range(1, len(sub_path) + 1):
+            branch_name = "/".join(sub_path[:idx])
+            if branch_name in branches:
+                directory_path = "/".join(sub_path[idx:]) if idx < len(sub_path) else None
+                return base_repo, branch_name, directory_path
+
+        # If no valid branch is found, raise an error
+        raise ValueError("Branch not found in repository")
+
     def eject_to_path(self, dest_path: pathlib.Path, src_sub_path: str = None):
 
         # clone the git repository to the target path

hyperpocket/server/server.py

@@ -136,11 +136,11 @@ class PocketServer(object):
         while True:
             if conn.poll():
                 op, uid, result, error = conn.recv()
-                if error:
-                    raise error
-
                 future = self.future_store[uid]
-                future.set_result(result)
+                if error:
+                    future.set_exception(error)
+                else:
+                    future.set_result(result)
                 break
             else:
                 await asyncio.sleep(0)
@@ -158,7 +158,7 @@ class PocketServer(object):
         self._set_mp_start_method()
 
         self.pipe = mp.Pipe()
-        self.process = mp.Process(target=self._run, args=(pocket_core,), daemon=True)
+        self.process = mp.Process(target=self._run, args=(pocket_core,))
         self.process.start()
 
     def _run(self, pocket_core):
@@ -185,9 +185,9 @@ class PocketServer(object):
         from hyperpocket.server.proxy import _generate_ssl_certificates
         from hyperpocket.server.proxy import https_proxy_app
 
-        from hyperpocket.config.settings import pocket_root
-        ssl_keypath = pocket_root / "callback_server.key"
-        ssl_certpath = pocket_root / "callback_server.crt"
+        from hyperpocket.config.settings import POCKET_ROOT
+        ssl_keypath = POCKET_ROOT / "callback_server.key"
+        ssl_certpath = POCKET_ROOT / "callback_server.crt"
 
         if not ssl_keypath.exists() or not ssl_certpath.exists():
             _generate_ssl_certificates(ssl_keypath, ssl_certpath)

hyperpocket/tool/function/tool.py

@@ -1,11 +1,9 @@
 import asyncio
 import copy
 import inspect
-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
@@ -47,32 +45,37 @@ class FunctionTool(Tool):
         _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", {}) | self.tool_vars
+                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
 
@@ -113,7 +116,7 @@ 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,
             default_tool_vars=tool_vars
@@ -123,10 +126,16 @@ class FunctionTool(Tool):
     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:
-            model = function_to_model(func)
+            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}")
@@ -142,6 +151,7 @@ class FunctionTool(Tool):
                     description=func.__doc__,
                     argument_json_schema=argument_json_schema,
                     auth=auth,
+                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
                 ))
             else:
                 tools.append(cls(
@@ -151,22 +161,6 @@ class FunctionTool(Tool):
                     description=func.__doc__,
                     argument_json_schema=argument_json_schema,
                     auth=auth,
+                    default_tool_vars=(tool_vars | func.__dict__.get("__vars__", {})),
                 ))
         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/tool.py

@@ -1,13 +1,11 @@
 import abc
-import pathlib
-
-import toml
 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
 
 
@@ -36,7 +34,7 @@ class ToolRequest(abc.ABC):
     @abc.abstractmethod
     def __str__(self):
         raise NotImplementedError
-    
+
     def add_postprocessing(self, postprocessing: Callable):
         if self.postprocessings is None:
             self.postprocessings = [postprocessing]
@@ -67,9 +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")
+    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:
@@ -84,17 +84,23 @@ 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
@@ -107,37 +113,40 @@ 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'] = '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.''',
+
+            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}")

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/util/extract_func_param_desc_from_docstring.py

@@ -23,14 +23,12 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     if not docstring:
         return {}
 
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by google style..")
     param_mapping = extract_param_desc_by_google_stype_docstring(docstring, func_params)
     if param_mapping:
         pocket_logger.debug(f"success extract docstring of {func.__name__} by google style!")
         return param_mapping
     pocket_logger.debug(f"not found param desc of {func.__name__} by google style..")
 
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by other style..")
     param_mapping = extract_param_desc_by_other_styles(docstring, func_params)
     if param_mapping:
         pocket_logger.debug(f"success extract docstring of {func.__name__} by other style!")
@@ -38,7 +36,6 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     pocket_logger.debug(f"not found param desc of {func.__name__} by other styles..")
 
     # Plain Text Style matching
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by plain text style..")
     param_descriptions = []
     for line in docstring.split("\n"):
         split_line = line.strip().split(":")
@@ -46,7 +43,8 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
             continue
 
         param_name = split_line[0]
-        cleaned_param_name = clean_bracket_content(param_name)
+        cleaned_param_name = clean_string(param_name)
+        cleaned_param_name = clean_bracket_content(cleaned_param_name)
         description = ":".join(split_line[1:]).strip()
         if cleaned_param_name in func_params:
             param_descriptions.append((cleaned_param_name, description))
@@ -58,6 +56,11 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     return param_mapping
 
 
+def clean_string(input_string):
+    cleaned = re.sub(r"^[^a-zA-Z_]*|[^a-zA-Z0-9_()\s]*$", "", input_string)
+    return cleaned.strip()
+
+
 def clean_bracket_content(content):
     return re.sub(r"[(\[{<].*?[)\]}>]", "", content)
 
@@ -65,9 +68,9 @@ def clean_bracket_content(content):
 def extract_param_desc_by_other_styles(docstring, func_params) -> dict[str, str]:
     param_descriptions = []
     # Pattern for Sphinx-style or Javadoc-style `:param`, `@param`, `:arg`, `@arg`
-    param_pattern = r"(?:@param|:param|:arg|@arg)\s+(\w+)(?:\s*:\s*|\s+|:\s+)(.*)"
-    matches = re.findall(param_pattern, docstring)
-    for param, desc in matches:
+    param_pattern = r"^\s*(?:@param|:param|:arg|@arg):?\s+(\w+)(?:\((.*?)\))?:?\s*(.*)"
+    matches = re.findall(param_pattern, docstring, re.MULTILINE)
+    for param, _, desc in matches:
         cleaned_param = clean_bracket_content(param)
         param_descriptions.append((cleaned_param, desc.strip()))
     # Ensure no duplicates and match with function parameters
@@ -87,7 +90,7 @@ def extract_param_desc_by_google_stype_docstring(docstring, func_params) -> dict
     param_descriptions = {}
     for line in param_lines:
         # Match parameter line with "name (type): description"
-        param_match = re.match(r"^\s*(\w+)\s*\(\s*(.*?)\s*\)\s*:\s*(.*)", line)
+        param_match = re.match(r"^[^a-zA-Z_]*([a-zA-Z_]\w*)\s*[\(\[]\s*(.*?)\s*[\)\]]\s*:\s*(.*)", line)
         if param_match:
             param, _, desc = param_match.groups()
             cleaned_param = clean_bracket_content(param)

hyperpocket/util/json_schema_to_model.py

@@ -70,6 +70,8 @@ def _convert_to_python_type(json_type, model_name, property_schema):
         field_type = str
     elif json_type == "boolean":
         field_type = bool
+    elif json_type == "number":
+        field_type = float
     elif json_type == "none":
         field_type = type(None)
     elif json_type == "object":

{hyperpocket-0.1.8.dist-info → hyperpocket-0.1.10.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.1.8
+Version: 0.1.10
 Summary: Building AI agent with hyperpocket tool in a flash
 Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
 Project-URL: Repository, https://github.com/vessl-ai/hyperpocket
-Author-email: VESSL AI Devs <dev@vessl.ai>
+Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1.7
 Requires-Dist: dynaconf>=3.2.6
@@ -23,20 +23,19 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: uvicorn>=0.32.1
 Description-Content-Type: text/markdown
 
-# Pocket 👛
+# Hyperpocket 👛
 
-Pocket is where tools belong. Power your agent up with a pocket of tools. 👛
+Hyperpocket is where tools belong. Power your agent up with a pocket of tools. 👛
 
 <figure>
-<img src="image.png" alt="4d-pocket" width="200"/>
-<figcaption>© Doraemon</figcaption>
+<img src="../../logo.png" alt="hyperpocket" width="200"/>
 </figure>
 
 ## Introduction
 
-Pocket is a tool that allows you to easily use tool and auth for agents on your machine.
+Hyperpocket is a tool that allows you to easily use tool and auth for agents on your machine.
 
-**_Start fast._** Just install Pocket and use it. We know you don't have time to authenticate to our server.
+**_Start fast._** Just install Hyperpocket and use it. We know you don't have time to authenticate to our server.
 
 **_Go securely._** Not like others, you are the only one who knows your secret tokens. We do NOT. All of your secret
 tokens belong to your infrastructure, not ours.
@@ -47,11 +46,6 @@ with the dependency spaghetti.
 
 **_Battery Included_** You can use popular tools and authentication providers out-of-the-box.
 
-<figure>
-<img src="pocket1.png" alt="pocket-flow" width="400"/>
-<figcaption></figcaption>
-</figure>
-
 ## Installation
 
 1. install hyperpocket
@@ -82,16 +76,16 @@ Or just use LLM API Clients out of the box.
 ### Using out-of-the-box tools
 
 ```python
-from hyperpocket.tool import from_git
+
 from langchain_openai import ChatOpenAI
 
 from hyperpocket_langchain import PocketLangchain
 
 pklc = PocketLangchain(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-    ]
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+  ]
 )
 tools = pklc.get_tools()
 
@@ -104,7 +98,7 @@ llm_tool_binding.invoke(...)
 
 There are two kinds of auth process, one is using system auth(developer api key) and the other is using end user auth.
 
-Pocket provides way to use end user auth easily.
+Hyperpocket provides way to use end user auth easily.
 (Of course, you can also just set your STRIPE_API_KEY when using Stripe API related tools)
 
 - Supported methods
@@ -130,7 +124,7 @@ Pocket provides way to use end user auth easily.
 You can manage your auths in request-wise level. (e.g. you can use different auths for different requests)
 
 ```python
-from hyperpocket.tool import from_git
+
 from langchain_openai import ChatOpenAI
 from langgraph.graph import StateGraph, START, MessagesState
 from langgraph.prebuilt import tools_condition
@@ -138,10 +132,10 @@ from langgraph.prebuilt import tools_condition
 from hyperpocket_langgraph import PocketLanggraph
 
 pklg = PocketLanggraph(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-    ],
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+  ],
 )
 llm = ChatOpenAI()
 
@@ -166,22 +160,21 @@ graph_builder.compile()
 ```
 
 ```python
-from hyperpocket.config import secret
-from hyperpocket.tool import from_git
 from llama_index.core.agent import FunctionCallingAgent
 from llama_index.llms.openai import OpenAI
 
+from hyperpocket.config import secret
 from hyperpocket_llamaindex import PocketLlamaindex
 
 llm = OpenAI(api_key=secret["OPENAI_API_KEY"])
 pocket = PocketLlamaindex(
-    tools=[
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/post-message"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/linear/get-issues"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/google/get-calendar-events"),
-        from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/google/get-calendar-list"),
-    ]
+  tools=[
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/linear/get-issues",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-events",
+    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-list",
+  ]
 )
 tools = pocket.get_tools()
 
@@ -218,12 +211,8 @@ Assistance: Here are the recent 10 messages.
 
 ### Config
 
-Running `pocket config init` will create your config file in `$HOME/.pocket/settings.toml`
-
 The `settings.toml` looks as follows.
 
-TODO: Add `secrets.toml`.
-
 ```toml
 log_level = "debug"
 internal_server_port = "8000" # optional, default is 8000
@@ -265,7 +254,7 @@ client_secret = ""  # your github client secret
 - While creating your github OAuth app, configuring your app's `Authorization callback URL` is different for your
   development environment and production environment.
   - For development environment, you can use `http://localhost:8000/auth/github/callback`
-    - **Note**: Default port for pocket dev server is `8000`. If you are using a different port, make sure to
+    - **Note**: Default port for hyperpocket dev server is `8000`. If you are using a different port, make sure to
       replace `8000` with your actual port number.
   - For production environment, you can use `https://yourdomain.com/auth/github/callback`
     - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.

{hyperpocket-0.1.8.dist-info → hyperpocket-0.1.10.dist-info}/RECORD

@@ -2,8 +2,8 @@ hyperpocket/__init__.py,sha256=iaJvrZ0rgHwAndGFVv8m1Iz_DWtWEcphFPL-1D8f9SY,136
 hyperpocket/builtin.py,sha256=FnsASGfieQKvVrFVESjvm73qsxPvCf7iiHGd7HNVpuQ,2371
 hyperpocket/constants.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/pocket_auth.py,sha256=-d5UvLkjvsSkem5DGrDphowckVCB3NCLt2jOw9k5U9c,16934
-hyperpocket/pocket_core.py,sha256=xyma8ucYVYID2gSnc5h5nF_nNMFFtimE-8la1IW1RZA,10035
-hyperpocket/pocket_main.py,sha256=UPdRS7ydQAmkqyGUj6ANf4lIr_oKXw-_71k37XCsOa4,10148
+hyperpocket/pocket_core.py,sha256=pt_IBciSlJUOq00siVNk_qVP3FK8PoIs2Bs7ZMsmm9U,10173
+hyperpocket/pocket_main.py,sha256=eSwevmX7vgRQebpNtOGG5jhVGU-DE_hTUJi-zRWAvdo,10231
 hyperpocket/prompts.py,sha256=XAmTTCzCkXWK50zcmWmGA25v9-HKd_4dL5o85uisbGM,472
 hyperpocket/tool_like.py,sha256=ur8oMU5p4DUYBEF5MBP3faQ7CKsOzb0lLOaL6p8JqSw,134
 hyperpocket/auth/README.md,sha256=zn4QqnFZCA_4X3x8Wb6lE3OP5otYxpByZaCiUkBvaNs,11562
@@ -77,16 +77,16 @@ hyperpocket/config/auth.py,sha256=5Zk7OZmElIqIn7LxsT7H4g3bimBxaKpnbL2v9Fs9MlA,79
 hyperpocket/config/git.py,sha256=CGbY7J1LyN4ccZr9CFGAQwwhjC9kvdU0On_nsAsZ1FQ,362
 hyperpocket/config/logger.py,sha256=Wwl-8lllaCNLZruxXU-bcC74Ciy5SmPOX4AJE5BUzWM,2769
 hyperpocket/config/session.py,sha256=CSXENtWx6Gh4DiPh4u9E-4MFYkM8JRjl2hSPV9PVfrE,801
-hyperpocket/config/settings.py,sha256=tKOFZdOk4pFa7RrPBTY7-NE7Bo_bBZS1Eeez03SedAU,2042
+hyperpocket/config/settings.py,sha256=yXwZN7eryNWxQCK5aRDHQRTzDLATzmSEZwo-6HCxELU,2017
 hyperpocket/futures/__init__.py,sha256=_pRnYZLbogkYFInA3jokkxrcEVRt6YNaBmkf_dSk3SM,136
 hyperpocket/futures/futurestore.py,sha256=WIJGX-XUdB4gWFu2Trto8vd3nTiLFOrnVzQhQP9bO_U,1316
 hyperpocket/repository/__init__.py,sha256=P4Ge__W5wqNgNILNzHjx7qgS8KRcbwri-nb4IPVVErs,219
-hyperpocket/repository/lock.py,sha256=nLuiszT3oECJJxVmTDdBARqv4x25DsKuL4253gJEJfI,6075
+hyperpocket/repository/lock.py,sha256=JhuRB1J1rpqGtN19Qeht-iM0BhFuxgl0EaGW9GzqDJA,8046
 hyperpocket/repository/lockfile.py,sha256=1cNkAv5WHU9o8b6arJn9wcosSp3gHMFe11mbAv72Cgs,2187
 hyperpocket/repository/repository.py,sha256=a0HA6eVA88Xq6MYe3SdqBji0U8_RuiaN2v2OYkT8nZY,1349
 hyperpocket/server/__init__.py,sha256=TLqok_mBeV3VRnbZ_spwrwwbsjJ1q9o375AdBk7tKNA,89
 hyperpocket/server/proxy.py,sha256=OhpAWpilM5ioKAsqInKudtvpYk56nMFeZ-dwoGAYIDA,1905
-hyperpocket/server/server.py,sha256=yktdzmh5vZj9y1n8i1vBHuNV5TAXeJBpKovO_RkAax0,7810
+hyperpocket/server/server.py,sha256=KPHl9WqRAQsQB-6c1D6nFvdJxxFW0dS__ZpF56oNcNU,7838
 hyperpocket/server/auth/__init__.py,sha256=IMjz9PCzD7qh4QIf2g-gWIdkDeU36jt-9F55vaHvLoM,286
 hyperpocket/server/auth/calendly.py,sha256=mi9_ysn0SffhnEgaoNa2jcHWCcD_yzqkS0rvzpJG2Qg,478
 hyperpocket/server/auth/github.py,sha256=cgUtdCYPhf_e51fEQgiYjyG6yuPfMV5RmltjujuWcBw,759
@@ -108,17 +108,15 @@ hyperpocket/session/interface.py,sha256=0o5IwXezaR5NKB6F9vfumLnrBSYv7JzY_FAvZB6u
 hyperpocket/session/redis.py,sha256=6SHR2ZJ5E3RS-G_xzeh5ls_cPZ0NarPetlEuaAtqEAk,5467
 hyperpocket/tool/README.md,sha256=vbHvP3fnfihq-H481MiSZEVJNhVoUu0djENb9tiy78c,3026
 hyperpocket/tool/__init__.py,sha256=PlSewsugQ6x4BXszWvmTiW-MfVS87TALvWi4TcIgreY,346
-hyperpocket/tool/tool.py,sha256=uP22MWN50nauFD9xkzc3jjGRO-nhxkYBaO1FVKiWu-Q,6778
+hyperpocket/tool/tool.py,sha256=9kALM1hk_IE1f9y9DK-_e0Ya5gNuP7oni1pfHU-e2_8,7282
 hyperpocket/tool/function/README.md,sha256=6Y9a8FlFjEdbrVqF0NoQ1j34VoV8Zt6Pf9-xlLIHkTc,3676
 hyperpocket/tool/function/__init__.py,sha256=elshxOWjKUCKSsSSkae8GB65bZ4xG1Xa4o2GCT5QbF4,259
 hyperpocket/tool/function/annotation.py,sha256=UaeawAkX3QNAWLYHCQ-V5UNZyfxpOOvbYs3w5Q8bJq4,1018
-hyperpocket/tool/function/tool.py,sha256=E9xND4Kv9nHGDGZEQTnQi9qEUmsnkwvl9J-k2LOJFKI,5953
+hyperpocket/tool/function/tool.py,sha256=EENaORdCLVz2HM7fdJhDsLCJfixDC4j2Hdf0GnJ-OOg,6034
 hyperpocket/tool/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hyperpocket/tool/tests/test_function_tool.py,sha256=If8M9DKkfh5voJyNU6Wdk-gqC9-ZpPEpinu8C7Mz2Zo,9569
-hyperpocket/tool/tests/test_wasm_tool.py,sha256=bKcx-w__pa1Yr3ZwB8TMODn95xczH-_cRKCSUAPR8iA,2420
 hyperpocket/tool/wasm/README.md,sha256=QeR7mI8RD6OJ2AXdZCpzNLBW0KUVgYQ0IqCc-wVXgFs,3896
 hyperpocket/tool/wasm/__init__.py,sha256=KGOPPyA1CnbW-T9bgSpfIXf9952l_p5HJDhHGBb3b9o,71
-hyperpocket/tool/wasm/browser.py,sha256=X2aw9sZy306dKDR0knqn4fGC6O1fw08M9t_zIkjUeWs,2083
+hyperpocket/tool/wasm/browser.py,sha256=a4TbetonEvClgkfQgTxpIN6a9IxZVB1jjSD3dBF8gNg,1851
 hyperpocket/tool/wasm/invoker.py,sha256=u8ZfGW871IVBaG4_XbOQHfp7QYLS093QdwVa3HOL-_k,1520
 hyperpocket/tool/wasm/script.py,sha256=b0il5tTF8bcMDcfR_ME8V2TppdnPDjNK2rB1GxeH5Pk,4251
 hyperpocket/tool/wasm/tool.py,sha256=GPTxgXEV9DbBbW848TqzNHvVbwk2oMmI__kUhHsuLNw,5199
@@ -126,14 +124,14 @@ hyperpocket/tool/wasm/templates/__init__.py,sha256=cQ-uNsO418xvv54i8bD0IrqcAKUxM
 hyperpocket/tool/wasm/templates/node.py,sha256=8ghVQGS9L3IJGdBB8waLK_ej4FS34dCA_bwPKjm8QSU,2782
 hyperpocket/tool/wasm/templates/python.py,sha256=Gi_tn3QQZjolFpbhVDXHLoj4juRLTEGsq_A-iyvTyUk,2733
 hyperpocket/util/__init__.py,sha256=V36_ztskLaKQxOhW2OhrhxRFn4QCxtX3jGjAT4lqNQE,35
-hyperpocket/util/extract_func_param_desc_from_docstring.py,sha256=3bek0BRwDGdlKBATDAhBrSSqzdVshXKD02zNi6KvxO4,4067
+hyperpocket/util/extract_func_param_desc_from_docstring.py,sha256=Ud1eRp1LyEO-qI34OUpZ1Osaxhzt_r93swRYFxbfSRs,4040
 hyperpocket/util/find_all_leaf_class_in_package.py,sha256=afGLqe5s7irOOPh7DI70v-utDL2a0vhNzHjtgSmDeZU,528
 hyperpocket/util/find_all_subclass_in_package.py,sha256=CfsM5sWHHbFZD6M-jbJRN8Zo3m57R1E7FGg_V__HdFU,964
 hyperpocket/util/flatten_json_schema.py,sha256=PXK6I1S2QDxwSGmUVEl5bbSPrjTa38GBllBQ8uKXJNQ,1587
 hyperpocket/util/function_to_model.py,sha256=zPBrxtvfieJearmvJeMOeIGGLn1ymXNvL9PlMoXZbwA,2061
 hyperpocket/util/get_objects_from_subpackage.py,sha256=Aq87PD_H57c2IjLS28Hf0Wu5vLVyoOtDoBvKzvQ1UPw,929
-hyperpocket/util/json_schema_to_model.py,sha256=fmIdIAkWfh7qLLoUrK4gqBV1JCHGQgjiEA8rwbpqoMg,3406
-hyperpocket-0.1.8.dist-info/METADATA,sha256=azLitNUYizbwI_VGTUmY2KvbQjtt-b6uaCkGeXq61dE,10170
-hyperpocket-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperpocket-0.1.8.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
-hyperpocket-0.1.8.dist-info/RECORD,,
+hyperpocket/util/json_schema_to_model.py,sha256=hmXqiU67WrdHZMGELvHfKxfQ12EqPtTD8x_KezCcEFk,3465
+hyperpocket-0.1.10.dist-info/METADATA,sha256=Rp9BULH23ZqLLSU2_POT_K9T_PaDkmXPpBYFzcYoNds,9577
+hyperpocket-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperpocket-0.1.10.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
+hyperpocket-0.1.10.dist-info/RECORD,,

hyperpocket/tool/tests/test_function_tool.py

@@ -1,321 +0,0 @@
-from unittest import TestCase
-
-from pydantic import BaseModel
-
-from hyperpocket.auth import AuthProvider
-from hyperpocket.tool.function.annotation import function_tool
-from hyperpocket.tool.function.tool import FunctionTool
-from hyperpocket.util.flatten_json_schema import flatten_json_schema
-
-
-class TestFunctionTool(TestCase):
-
-    def test_function_tool_call(self):
-        # given
-        @function_tool
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-            a(int): first name
-            b(int): second name
-            """
-            return a + b
-
-        # when
-        result = add_numbers.invoke(body={
-            "a": 1,
-            "b": 2
-        })
-
-        # 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
-        class FirstNumber(BaseModel):
-            first: int
-
-        class SecondNumber(BaseModel):
-            second: int
-
-        @function_tool
-        def add_numbers(a: FirstNumber, b: SecondNumber):
-            """
-            add two numbers
-            a(FirstNumber): first number
-            b(SecondNumber): second number
-            """
-            return a.first + b.second
-
-        # when
-        result = add_numbers.invoke(body={
-            "a": {
-                "first": 1,
-            },
-            "b": {
-                "second": 2
-            }
-        })
-
-        # then
-        self.assertEqual(result, '3')
-
-    def test_register_no_auth_no_init_func_case(self):
-        """
-        Test register functionTool in case of no-auth and no-init function
-        """
-
-        @function_tool
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-            a(int): first name
-            b(int): second name
-            """
-            return a + b
-
-        # when
-        result = add_numbers.invoke(body={
-            "a": 1,
-            "b": 2
-        })
-
-        # then
-        self.assertIsInstance(add_numbers, FunctionTool)
-        self.assertEqual(result, '3')
-
-    def test_register_no_auth_init_func_case(self):
-        """
-        Test register functionTool in case of no-auth and init function
-        """
-
-        @function_tool()
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-            a(int): first name
-            b(int): second name
-            """
-            return a + b
-
-        # when
-        result = add_numbers.invoke(body={
-            "a": 1,
-            "b": 2
-        })
-
-        # then
-        self.assertIsInstance(add_numbers, FunctionTool)
-        self.assertEqual(result, '3')
-
-    def test_register_auth_init_func_case(self):
-        """
-        Test register functionTool in case of auth and init function
-
-        """
-
-        @function_tool(auth_provider=AuthProvider.SLACK)
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-            a(int): first name
-            b(int): second name
-            """
-            return a + b
-
-        # when
-        result = add_numbers.invoke(body={
-            "a": 1,
-            "b": 2
-        },
-            envs={
-                "SLACK_BOT_TOKEN": "test"
-            })
-
-        # then
-        self.assertIsInstance(add_numbers, FunctionTool)
-        self.assertEqual(result, '3')
-
-    def test_google_style_docstring_parsing(self):
-        """
-        Test google style docstring parsing
-        """
-
-        # given
-        @function_tool
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-
-            Args:
-                a(int): first name
-                b(int): second name
-            """
-            return a + b
-
-        # when
-        schema = add_numbers.schema_model()
-        schema_json = schema.model_json_schema()
-        flatten_schema_json = flatten_json_schema(schema_json)
-        func_schema = flatten_schema_json["properties"]["body"]
-
-        # then
-        self.assertTrue(str(func_schema["description"]).startswith("add two numbers"))
-        self.assertEqual(func_schema["title"], "add_numbers")
-        self.assertEqual(func_schema["required"], ["a", "b"])
-        self.assertEqual(func_schema["type"], "object")
-        self.assertEqual(func_schema["properties"]["a"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["a"]["description"], "first name")
-        self.assertEqual(func_schema["properties"]["b"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["b"]["description"], "second name")
-
-    def test_javadoc_style_docstring_parsing(self):
-        """
-        Test javadoc style docstring parsing
-        """
-
-        # given
-        @function_tool
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-
-            @param a first name
-            @param b second name
-            """
-            return a + b
-
-        # when
-        schema = add_numbers.schema_model()
-        schema_json = schema.model_json_schema()
-        flatten_schema_json = flatten_json_schema(schema_json)
-        func_schema = flatten_schema_json["properties"]["body"]
-
-        # then
-        self.assertTrue(str(func_schema["description"]).startswith("add two numbers"))
-        self.assertEqual(func_schema["title"], "add_numbers")
-        self.assertEqual(func_schema["required"], ["a", "b"])
-        self.assertEqual(func_schema["type"], "object")
-        self.assertEqual(func_schema["properties"]["a"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["a"]["description"], "first name")
-        self.assertEqual(func_schema["properties"]["b"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["b"]["description"], "second name")
-
-    def test_sphinx_style_docstring_parsing(self):
-        """
-        Test sphinx style docstring parsing
-        """
-
-        # given
-        @function_tool
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-
-            :param a: first name
-            :param b: second name
-            """
-            return a + b
-
-        # when
-        schema = add_numbers.schema_model()
-        schema_json = schema.model_json_schema()
-        flatten_schema_json = flatten_json_schema(schema_json)
-        func_schema = flatten_schema_json["properties"]["body"]
-
-        # then
-        self.assertTrue(str(func_schema["description"]).startswith("add two numbers"))
-        self.assertEqual(func_schema["title"], "add_numbers")
-        self.assertEqual(func_schema["required"], ["a", "b"])
-        self.assertEqual(func_schema["type"], "object")
-        self.assertEqual(func_schema["properties"]["a"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["a"]["description"], "first name")
-        self.assertEqual(func_schema["properties"]["b"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["b"]["description"], "second name")
-
-    def test_simple_style_docstring_parsing(self):
-        """
-        Test simple docstring parsing
-        """
-
-        # given
-        @function_tool
-        def add_numbers(a: int, b: int):
-            """
-            add two numbers
-
-            a: first name
-            b(int): second name
-            """
-            return a + b
-
-        # when
-        schema = add_numbers.schema_model()
-        schema_json = schema.model_json_schema()
-        flatten_schema_json = flatten_json_schema(schema_json)
-        func_schema = flatten_schema_json["properties"]["body"]
-
-        # then
-        self.assertTrue(str(func_schema["description"]).startswith("add two numbers"))
-        self.assertEqual(func_schema["title"], "add_numbers")
-        self.assertEqual(func_schema["required"], ["a", "b"])
-        self.assertEqual(func_schema["type"], "object")
-        self.assertEqual(func_schema["properties"]["a"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["a"]["description"], "first name")
-        self.assertEqual(func_schema["properties"]["b"]["type"], "integer")
-        self.assertEqual(func_schema["properties"]["b"]["description"], "second name")

hyperpocket/tool/tests/test_wasm_tool.py

@@ -1,73 +0,0 @@
-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")
-