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

hyperpocket/server/server.py

@@ -8,6 +8,7 @@ from fastapi import FastAPI
 from uvicorn import Config, Server
 
 from hyperpocket.config import config, pocket_logger
+from hyperpocket.pocket_core import PocketCore
 from hyperpocket.server.auth import auth_router
 from hyperpocket.server.tool import tool_router
 
@@ -27,6 +28,7 @@ class PocketServer(object):
     pipe: mp.Pipe
     process: mp.Process
     future_store: dict[str, asyncio.Future]
+    torn_down: bool = False
 
     def __init__(self,
                  internal_server_port: int = config.internal_server_port,
@@ -36,9 +38,12 @@ class PocketServer(object):
         self.future_store = dict()
 
     def teardown(self):
-        if self.process and self.process.is_alive():
-            self.process.terminate()
-            self.process.join()
+        # @XXX(seokju) is it ok to call this method both in __del__ and __exit__?
+        if self.torn_down:
+            return
+        self.torn_down = True
+        self.process.terminate()
+        self.process.join()
 
     async def _run_async(self):
         try:
@@ -55,20 +60,48 @@ class PocketServer(object):
         _, conn = self.pipe
 
         async def _acall(_conn, _op, _uid, a, kw):
-            result = await self.child_pocket.acall(*a, **kw)
-            _conn.send((_op, _uid, result))
+            try:
+                result = await self.pocket_core.acall(*a, **kw)
+                error = None
+            except Exception as e:
+                pocket_logger.error(f"failed to acall in pocket subprocess. error: {e}")
+                result = None
+                error = e
+
+            _conn.send((_op, _uid, result, error))
 
         async def _prepare(_conn, _op, _uid, a, kw):
-            result = self.child_pocket.prepare_auth(*a, **kw)
-            _conn.send((_op, _uid, result))
+            try:
+                result = self.pocket_core.prepare_auth(*a, **kw)
+                error = None
+            except Exception as e:
+                pocket_logger.error(f"failed to prepare in pocket subprocess. error: {e}")
+                result = None
+                error = e
+
+            _conn.send((_op, _uid, result, error))
 
         async def _authenticate(_conn, _op, _uid, a, kw):
-            result = await self.child_pocket.authenticate(*a, **kw)
-            _conn.send((_op, _uid, result))
+            try:
+                result = await self.pocket_core.authenticate(*a, **kw)
+                error = None
+            except Exception as e:
+                pocket_logger.error(f"failed to authenticate in pocket subprocess. error: {e}")
+                result = None
+                error = e
+
+            _conn.send((_op, _uid, result, error))
 
         async def _tool_call(_conn, _op, _uid, a, kw):
-            result = await self.child_pocket.tool_call(*a, **kw)
-            _conn.send((_op, _uid, result))
+            try:
+                result = await self.pocket_core.tool_call(*a, **kw)
+                error = None
+            except Exception as e:
+                pocket_logger.error(f"failed to tool_call in pocket subprocess. error: {e}")
+                result = None
+                error = e
+
+            _conn.send((_op, _uid, result, error))
 
         while True:
             if conn.poll():
@@ -102,7 +135,10 @@ class PocketServer(object):
         conn, _ = self.pipe
         while True:
             if conn.poll():
-                op, uid, result = conn.recv()
+                op, uid, result, error = conn.recv()
+                if error:
+                    raise error
+
                 future = self.future_store[uid]
                 future.set_result(result)
                 break
@@ -118,15 +154,15 @@ class PocketServer(object):
         loop.create_task(self.poll_in_parent())
         return await self.future_store[uid]
 
-    def run(self, child_pocket):
+    def run(self, pocket_core: PocketCore):
         self._set_mp_start_method()
 
         self.pipe = mp.Pipe()
-        self.process = mp.Process(target=self._run, args=(child_pocket,), daemon=True)
+        self.process = mp.Process(target=self._run, args=(pocket_core,), daemon=True)
         self.process.start()
 
-    def _run(self, child_pocket):
-        self.child_pocket = child_pocket
+    def _run(self, pocket_core):
+        self.pocket_core = pocket_core
         self.main_server = self._create_main_server()
         self.proxy_server = self._create_https_proxy_server()
         loop = asyncio.new_event_loop()

hyperpocket/server/tool/dto/script.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from pydantic import BaseModel, Field
 
 from hyperpocket.tool.wasm.script import ScriptFileNode
@@ -8,8 +9,20 @@ class Script(BaseModel):
     tool_id: str = Field(alias='tool_id')
 
 
-class ScriptStdout(BaseModel):
-    stdout: str = Field(alias='stdout')
+class ScriptResult(BaseModel):
+    stdout: Optional[str] = Field(alias='stdout', default=None)
+    stderr: Optional[str] = Field(alias='stderr', default=None)
+    error: Optional[str] = Field(alias='error', default=None)
 
 class ScriptFileTree(BaseModel):
     tree: dict[str, ScriptFileNode] = Field(alias='tree')
+
+class ScriptEntrypoint(BaseModel):
+    package_name: Optional[str] = Field(alias='package_name')
+    entrypoint: str = Field(alias='entrypoint')
+
+class ScriptEncodedFile(BaseModel):
+    encoded_file: str = Field(alias='encoded_file')
+
+class ScriptFileRequest(BaseModel):
+    path: str = Field(alias='path')

hyperpocket/server/tool/wasm.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, FileResponse
 
 from hyperpocket.futures import FutureStore
 from hyperpocket.server.tool.dto import script as scriptdto
@@ -17,15 +17,27 @@ async def browse_script_page(script_id: str):
 
 
 @wasm_tool_router.post("/scripts/{script_id}/done")
-async def done_script_page(script_id: str, req: scriptdto.ScriptStdout) -> scriptdto.ScriptStdout:
-    FutureStore.resolve_future(script_id, req.stdout)
-    return scriptdto.ScriptStdout(stdout=req.stdout)
-
-@wasm_tool_router.post("/scripts/{script_id}/fail")
-async def fail_script_page(script_id: str, req: scriptdto.ScriptStdout) -> scriptdto.ScriptStdout:
-    pass
+async def done_script_page(script_id: str, req: scriptdto.ScriptResult) -> scriptdto.ScriptResult:
+    FutureStore.resolve_future(script_id, {
+        'stdout': req.stdout,
+        'stderr': req.stderr,
+        'error': req.error
+    })
+    return req
 
 @wasm_tool_router.get("/scripts/{script_id}/file_tree")
 async def get_file_tree(script_id: str) -> scriptdto.ScriptFileTree:
     script = ScriptStore.get_script(script_id)
     return scriptdto.ScriptFileTree(tree=script.load_file_tree())
+
+@wasm_tool_router.get("/scripts/{script_id}/entrypoint")
+async def get_entrypoint(script_id: str) -> scriptdto.ScriptEntrypoint:
+    script = ScriptStore.get_script(script_id)
+    package_name = script.package_name
+    entrypoint = f"/tools/wasm/scripts/{script_id}/file/{script.entrypoint}"
+    return scriptdto.ScriptEntrypoint(package_name=package_name, entrypoint=entrypoint)
+
+@wasm_tool_router.get("/scripts/{script_id}/file/{file_name}", response_class=FileResponse)
+async def get_dist_file(script_id: str, file_name: str):
+    script = ScriptStore.get_script(script_id)
+    return FileResponse(script.dist_file_path(file_name))

hyperpocket/session/README.md

@@ -55,7 +55,7 @@ To Be Updated (TBU)
 
 ## How to Implement
 
-1. Add the SessionType enum in `pocket/config/session.py`.
-2. Add the SessionConfig in `pocket/config/session.py`.
+1. Add the SessionType enum in `hyperpocket/config/session.py`.
+2. Add the SessionConfig in `hyperpocket/config/session.py`.
 3. Implement the SessionStorageInterface
     - The session storage must be initialized with the SessionConfig defined above.

hyperpocket/session/in_memory.py

@@ -1,3 +1,4 @@
+import re
 from typing import Dict, List, Optional
 
 from hyperpocket.auth import AuthProvider
@@ -22,9 +23,21 @@ class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemor
         return SessionType.IN_MEMORY
 
     def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> Optional[V]:
-        key = self._make_session_key(auth_provider, thread_id, profile)
+        key = self._make_session_key(auth_provider.name, thread_id, profile)
         return self.storage.get(key, None)
 
+    def get_by_thread_id(self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs) -> List[V]:
+        if auth_provider is None:
+            auth_provider_name = ".*"
+        else:
+            auth_provider_name = auth_provider.name
+
+        pattern = rf'{self._make_session_key(auth_provider_name, thread_id, ".*")}'
+        compiled = re.compile(pattern)
+
+        session_list = [value for key, value in self.storage.items() if compiled.match(key)]
+        return session_list
+
     def set(self, auth_provider: AuthProvider,
             thread_id: str,
             profile: str,
@@ -32,7 +45,7 @@ class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemor
             auth_resolve_uid: Optional[str],
             auth_context: Optional[AuthContext],
             is_auth_scope_universal: bool, **kwargs) -> V:
-        key = self._make_session_key(auth_provider, thread_id, profile)
+        key = self._make_session_key(auth_provider.name, thread_id, profile)
         session = self._make_session(
             auth_provider_name=auth_provider.name,
             auth_scopes=auth_scopes,
@@ -44,7 +57,7 @@ class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemor
         return session
 
     def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
-        key = self._make_session_key(auth_provider, thread_id, profile)
+        key = self._make_session_key(auth_provider.name, thread_id, profile)
         if key in self.storage:
             self.storage.pop(key)
             return True
@@ -52,9 +65,9 @@ class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemor
         return False
 
     @staticmethod
-    def _make_session_key(auth_provider: AuthProvider, thread_id: str, profile: str) -> K:
+    def _make_session_key(auth_provider_name: str, thread_id: str, profile: str) -> K:
         return "{auth_provider}{delimiter}{thread_id}{delimiter}{profile}".format(
-            auth_provider=auth_provider.name,
+            auth_provider=auth_provider_name,
             thread_id=thread_id,
             profile=profile,
             delimiter=SESSION_KEY_DELIMITER,

hyperpocket/session/interface.py

@@ -68,6 +68,20 @@ class SessionStorageInterface(ABC, Generic[K, V]):
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_by_thread_id(self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs) -> List[V]:
+        """
+        Get session list by thread id
+
+        Args:
+            auth_provider (AuthProvider): auth provider
+            thread_id (str): thread id
+
+        Returns:
+            List[V(BaseSessionValue)]: Session List
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def set(self,
             auth_provider: AuthProvider,

hyperpocket/session/redis.py

@@ -25,7 +25,7 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
         return SessionType.REDIS
 
     def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> Optional[V]:
-        key = self._make_session_key(auth_provider, thread_id, profile)
+        key = self._make_session_key(auth_provider.name, thread_id, profile)
         raw_session: Any = self.client.get(key)
         if raw_session is None:
             return None
@@ -33,6 +33,30 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
         session = self._deserialize(raw_session)
         return session
 
+    def get_by_thread_id(self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs) -> List[V]:
+        if auth_provider is None:
+            auth_provider_name = "*"
+        else:
+            auth_provider_name = auth_provider.name
+
+        pattern = self._make_session_key(auth_provider_name, thread_id, "*")
+        key_list = []
+        cursor = 0
+        while True:
+            cursor, keys = self.client.scan(cursor=cursor, match=pattern)
+            key_list.extend(keys)
+            if cursor == 0:
+                break
+
+        with self.client.pipeline() as pipe:
+            for key in key_list:
+                pipe.get(key)
+
+            raw_sessions = pipe.execute()
+        session_list = [self._deserialize(raw) for raw in raw_sessions]
+
+        return session_list
+
     def set(self, auth_provider: AuthProvider,
             thread_id: str,
             profile: str,
@@ -47,20 +71,20 @@ class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionV
             auth_resolve_uid=auth_resolve_uid,
             is_auth_scope_universal=is_auth_scope_universal)
 
-        key = self._make_session_key(auth_provider, thread_id, profile)
+        key = self._make_session_key(auth_provider.name, thread_id, profile)
 
         raw_session = self._serialize(session)
         self.client.set(key, raw_session)
         return session
 
     def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
-        key = self._make_session_key(auth_provider, thread_id, profile)
+        key = self._make_session_key(auth_provider.name, thread_id, profile)
         return self.client.delete(key) == 1
 
     @staticmethod
-    def _make_session_key(auth_provider: AuthProvider, thread_id: str, profile: str) -> K:
+    def _make_session_key(auth_provider_name: str, thread_id: str, profile: str) -> K:
         return "{auth_provider}{delimiter}{thread_id}{delimiter}{profile}".format(
-            auth_provider=auth_provider.name,
+            auth_provider=auth_provider_name,
             thread_id=thread_id,
             profile=profile,
             delimiter=SESSION_KEY_DELIMITER,

hyperpocket/tool/README.md

@@ -13,13 +13,15 @@ The class that contains authentication information to invoke tool
 authentication information fields are:
 
 - `auth_provider`: Indicates which authentication provider’s credentials are required to invoke the tool.
-    - If auth_provider is not specified, the tool is considered to require no authentication.
+
+  - If auth_provider is not specified, the tool is considered to require no authentication.
 
 - `auth_handler`: Specifies which authentication handler should be used when invoking the tool.
-    - If auth_handler is not specified, the default handler of the authentication provider will be used.
+
+  - If auth_handler is not specified, the default handler of the authentication provider will be used.
 
 - `scopes`: Indicates the authentication scopes required to invoke the tool.
-    - If authentication is not performed or the authentication handler is non-scoped, the value should be None.
+  - If authentication is not performed or the authentication handler is non-scoped, the value should be None.
 
 ## Tool
 
@@ -31,6 +33,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")
 ```
 
 ### schema_model
@@ -43,16 +48,18 @@ In this process, the original `argument_json_schema` is moved under the `body` f
 ## How to implement
 
 1. Create a class that inherits from Tool
-    - Define the tasks to be performed when invoking the tool in invoke or ainvoke.
-    - Define a factory method to initialize the tool.(Optional)
-    - Inject values for the required fields during initialization.
+
+   - Define the tasks to be performed when invoking the tool in invoke or ainvoke.
+   - Define a factory method to initialize the tool.(Optional)
+   - Inject values for the required fields during initialization.
 
 2. Add the class to `ToolLike` in Pocket (Optional)
-    - For `WasmTool`, the input can be a ToolRequest or a str.
-    - For `FunctionTool`, the input can be a Callable.
+
+   - For `WasmTool`, the input can be a ToolRequest or a str.
+   - For `FunctionTool`, the input can be a Callable.
 
 3. Perform tool initialization in `Pocket.__init__` or `Pocket._load_tool`
-    - The initialization is based on the provided ToolLike value.
+   - The initialization is based on the provided ToolLike value.
 
 ## Invoke Flow
 
@@ -70,6 +77,3 @@ flowchart TD
     B -->|No| F
     E --> F["Tool: Perform Operations"]
 ```
-
-
-

hyperpocket/tool/__init__.py

@@ -1,4 +1,4 @@
-from hyperpocket.tool.function import from_func, function_tool
+from hyperpocket.tool.function import from_dock, from_func, function_tool
 from hyperpocket.tool.tool import Tool, ToolRequest, ToolAuth
 from hyperpocket.tool.wasm.tool import from_local, from_git
 
@@ -8,6 +8,7 @@ __all__ = [
     'ToolRequest',
     'from_local',
     'from_git',
-    "from_func",
-    "function_tool"
+    'from_dock',
+    'from_func',
+    'function_tool'
 ]

hyperpocket/tool/function/README.md

@@ -64,7 +64,7 @@ Pocket(tools=[
 ])
 ```
 
-Authentication access tokens are passed to the Python function as __variable keyword__ arguments.
+Authentication access tokens are passed to the Python function as **variable keyword** arguments.
 
 ```python
 from hyperpocket.tool import function_tool
@@ -82,6 +82,35 @@ def my_function(**kwargs):
 
 - Check the `_ACCESS_TOKEN_KEY` field of each provider for the mapping key of their access tokens.
 
+### Inject tool variables
+
+If the user specifies `tool_vars` in the `@function_tool` decorator, which are allowed to be injected dynamically when the user develops an agent, it can be injected through the following steps.
+
+```python
+@function_tool(
+    tool_vars={
+        'a': '1',
+        'b': '1',
+    },
+)
+def always_two(**kwargs):
+    a = int(kwargs['a'])
+    b = int(kwargs['b'])
+    return str(a+b)
+```
+
+1. Injecting tool_vars when importing tool in code
+
+```python
+from_func('https://github.com/your-organization/your-repository/tree/main',
+tool_vars = {
+    "b": "2"
+})
+```
+
+2. Injecting tool_vars by settings.toml
+   Hyperpocket checks the `settings.toml` from the agent code directory and modify the tool_vars.
+
 ## Docstring Parsing
 
 Parse docstrings to understand the meanings of arguments.
@@ -99,7 +128,7 @@ The following docstring styles are supported:
 def my_function(a: int, b: int):
     """
     My Function
-    
+
     Args:
         a (int): First argument
         b (int): Second argument
@@ -113,7 +142,7 @@ def my_function(a: int, b: int):
 def my_function(a: int, b: int):
     """
     My Function
-        
+
     :param a: First argument
     :param b: Second argument
     """
@@ -126,7 +155,7 @@ def my_function(a: int, b: int):
 def my_function(a: int, b: int):
     """
     My Function
-        
+
     @param a: First argument
     @param b: Second argument
     """
@@ -139,12 +168,12 @@ def my_function(a: int, b: int):
 def my_function(a: int, b: int):
     """
     My Function
-        
+
     @arg a: First argument
     @arg b: Second argument
-    
-    or 
-      
+
+    or
+
     :arg a: First argument
     :arg b: Second argument
     """
@@ -157,7 +186,7 @@ def my_function(a: int, b: int):
 def my_function(a: int, b: int):
     """
     My Function
-        
+
     a(int): First argument
     b(int): Second argument
     """
@@ -166,4 +195,4 @@ def my_function(a: int, b: int):
 
 ## Limitations
 
-Input types are limited to Python built-in types and Pydantic.
+Input types are limited to Python built-in types and Pydantic.

hyperpocket/tool/function/__init__.py

@@ -2,8 +2,10 @@ from hyperpocket.tool.function.annotation import function_tool
 from hyperpocket.tool.function.tool import FunctionTool
 
 from_func = FunctionTool.from_func
+from_dock = FunctionTool.from_dock
 
 __all__ = [
     "from_func",
+    "from_dock",
     "function_tool"
 ]

hyperpocket/tool/function/annotation.py

@@ -6,7 +6,7 @@ from hyperpocket.tool.tool import ToolAuth
 
 
 def function_tool(func: Optional[Callable] = None, *, auth_provider: AuthProvider = None, scopes: List[str] = None,
-                  auth_handler: str = None):
+                  auth_handler: str = None, tool_vars: dict[str, str] = None):
     def decorator(inner_func: Callable):
         if not callable(inner_func):
             raise ValueError("FunctionTool can only be created from a callable")
@@ -21,6 +21,7 @@ def function_tool(func: Optional[Callable] = None, *, auth_provider: AuthProvide
         return FunctionTool.from_func(
             func=inner_func,
             auth=auth,
+            tool_vars=tool_vars
         )
 
     if func is not None: