hyperpocket 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

hyperpocket/auth/basicauth/README.md

@@ -0,0 +1,28 @@
+### API Token Auth
+
+This module provides authentication using simple API tokens.
+
+1. To use this authentication in your tool, include the following in your `config.toml`:
+
+```toml
+[auth]
+auth_provider = "apitoken"
+auth_handler = "apitoken"
+scopes = []
+```
+
+2. To use it with `function_tool`, you can define your function as follows:
+
+```python
+from hyperpocket.tool import function_tool
+from hyperpocket.auth import AuthProvider
+
+
+@function_tool(
+    auth_provider=AuthProvider.API_TOKEN
+)
+def my_function(**kwargs):
+    token = kwargs["API_TOKEN"]
+
+    # ...
+```

hyperpocket/auth/basicauth/basicauth_context.py

@@ -0,0 +1,14 @@
+from hyperpocket.auth.basicauth.context import BasicAuthContext
+from hyperpocket.auth.basicauth.basicauth_schema import (
+    BasicAuthResponse,
+)
+
+
+class BasicAuthContext(BasicAuthContext):
+    @classmethod
+    def from_api_token_response(cls, response: BasicAuthResponse):
+        description = "Api Token Context logged in"
+
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/basicauth/basicauth_handler.py

@@ -0,0 +1,94 @@
+from typing import Optional
+from urllib.parse import urlencode, urljoin
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface
+from hyperpocket.auth.basicauth.basicauth_context import BasicAuthContext
+from hyperpocket.auth.basicauth.basicauth_schema import (
+    BasicAuthRequest,
+    BasicAuthResponse,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class BasicAuthHandler(AuthHandlerInterface):
+    name: str = "basicauth"
+    description: str = (
+        "This handler is used to authenticate users using the Basic Auth."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/basicauth",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.BASICAUTH
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    def prepare(
+        self,
+        auth_req: BasicAuthRequest,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
+        redirect_uri = urljoin(
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/basicauth/token/callback",
+        )
+        url = self._make_auth_url(
+            auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid
+        )
+        FutureStore.create_future(
+            future_uid,
+            data={
+                "redirect_uri": redirect_uri,
+                "thread_id": thread_id,
+                "profile": profile,
+            },
+        )
+
+        return f"User needs to authenticate using the following URL: {url}"
+
+    async def authenticate(
+        self, auth_req: BasicAuthRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = BasicAuthResponse(access_token=access_token)
+        context = BasicAuthContext.from_api_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: BasicAuthRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Basic auth doesn't support refresh")
+
+    def _make_auth_url(self, auth_req: BasicAuthRequest, redirect_uri: str, state: str):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> BasicAuthRequest:
+        return BasicAuthRequest()

hyperpocket/auth/basicauth/basicauth_schema.py

@@ -0,0 +1,9 @@
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class BasicAuthRequest(AuthenticateRequest):
+    pass
+
+
+class BasicAuthResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/basicauth/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class BasicAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "BASIC_AUTH"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/hubspot/oauth2_context.py

@@ -12,9 +12,7 @@ class HubspotOAuth2AuthContext(HubspotAuthContext):
 
     @classmethod
     def from_hubspot_oauth2_response(cls, response: HubspotOAuth2Response):
-        description = (
-            f"Hubspot OAuth2 Context logged in as a user {response.authed_user.id}"
-        )
+        description = "Hubspot OAuth2 Context logged in"
         now = datetime.now(tz=timezone.utc)
 
         access_token = response.access_token
@@ -22,7 +20,7 @@ class HubspotOAuth2AuthContext(HubspotAuthContext):
         expires_in = response.expires_in
 
         if expires_in:
-            expires_at = now + timedelta(seconds=response.authed_user.expires_in)
+            expires_at = now + timedelta(seconds=response.expires_in)
         else:
             expires_at = None
 

hyperpocket/auth/linkedin/basicauth_context.py

@@ -0,0 +1,14 @@
+from hyperpocket.auth.linkedin.context import LinkedinAuthContext
+from hyperpocket.auth.linkedin.basicauth_schema import LinkedinBasicAuthResponse
+
+
+class LinkedinBasicAuthContext(LinkedinAuthContext):
+    _ACCESS_TOKEN_KEY: str = "LINKEDIN_BASIC_AUTH"
+
+    @classmethod
+    def from_api_token_response(cls, response: LinkedinBasicAuthResponse):
+        description = "Api Token Context logged in"
+
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/linkedin/basicauth_handler.py

@@ -0,0 +1,97 @@
+from typing import Optional
+from urllib.parse import urlencode, urljoin
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+from hyperpocket.auth.linkedin.basicauth_context import LinkedinBasicAuthContext
+from hyperpocket.auth.linkedin.basicauth_schema import (
+    LinkedinBasicAuthRequest,
+    LinkedinBasicAuthResponse,
+)
+
+
+class LinkedinBasicAuthHandler(AuthHandlerInterface):
+    name: str = "linkedin-basicauth"
+    description: str = (
+        "This handler is used to authenticate users using the Basic Auth."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/basicauth",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.LINKEDIN
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    def prepare(
+        self,
+        auth_req: LinkedinBasicAuthRequest,
+        thread_id: str,
+        profile: str,
+        future_uid: str,
+        *args,
+        **kwargs,
+    ) -> str:
+        redirect_uri = urljoin(
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/linkedin/basicauth/callback",
+        )
+        url = self._make_auth_url(
+            auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid
+        )
+        FutureStore.create_future(
+            future_uid,
+            data={
+                "redirect_uri": redirect_uri,
+                "thread_id": thread_id,
+                "profile": profile,
+            },
+        )
+
+        return f"User needs to authenticate using the following URL: {url}"
+
+    async def authenticate(
+        self, auth_req: LinkedinBasicAuthRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = LinkedinBasicAuthResponse(access_token=access_token)
+        context = LinkedinBasicAuthContext.from_api_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: LinkedinBasicAuthRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Basic auth doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: LinkedinBasicAuthRequest, redirect_uri: str, state: str
+    ):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> LinkedinBasicAuthRequest:
+        return LinkedinBasicAuthRequest()

hyperpocket/auth/linkedin/basicauth_schema.py

@@ -0,0 +1,9 @@
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class LinkedinBasicAuthRequest(AuthenticateRequest):
+    pass
+
+
+class LinkedinBasicAuthResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/linkedin/oauth2_handler.py

@@ -29,7 +29,7 @@ class LinkedinOAuth2AuthHandler(AuthHandlerInterface):
 
     @staticmethod
     def provider_default() -> bool:
-        return True
+        return False
 
     @staticmethod
     def recommended_scopes() -> set[str]:

hyperpocket/auth/provider.py

@@ -75,6 +75,7 @@ class AuthProvider(Enum):
     WEAVIATE = "weaviate"
     VALYU = "valyu"
     KRAKEN = "kraken"
+    BASICAUTH = "basicauth"
 
     @classmethod
     def get_auth_provider(cls, auth_provider_name: str) -> "AuthProvider":

hyperpocket/config/auth.py

@@ -104,6 +104,7 @@ class AuthConfig(BaseModel):
     linear: Optional[LinearAuthConfig] = None
     facebook: Optional[FacebookAuthConfig] = None
     use_prebuilt_auth: bool = Field(default=True)
+    auth_encryption_secret_key: Optional[str] = Field(default=None)
 
 
 DefaultAuthConfig = AuthConfig()

hyperpocket/server/auth/basicauth.py

@@ -0,0 +1,88 @@
+import base64
+from http import HTTPStatus
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+
+from cryptography.fernet import Fernet
+from fastapi import APIRouter, Form
+from starlette.responses import HTMLResponse, RedirectResponse
+
+from hyperpocket.config import config
+from hyperpocket.config.auth import DefaultAuthConfig
+from hyperpocket.futures import FutureStore
+
+default_router = APIRouter()
+
+
+@default_router.get("/basicauth", response_class=HTMLResponse)
+async def basicauth_form(redirect_uri: str, state: str = ""):
+    html = f"""    
+    <html>
+        <body>
+            <h2>Enter ID and Password</h2>
+                     <form action="submit" method="post">
+                <input type="hidden" name="redirect_uri" value="{redirect_uri}">
+                <input type="hidden" name="state" value="{state}">
+                
+                <label for="username">Username:</label>
+                <input type="text" id="username" name="username" required>
+                
+                <label for="password">Password:</label>
+                <input type="password" id="password" name="password" required>
+                
+                <button type="submit">submit</button>
+            </form>
+        </body>
+    </html>
+    """
+    return HTMLResponse(content=html)
+
+
+@default_router.post("/submit", response_class=RedirectResponse)
+async def submit_basicauth(
+    username: str = Form(...),
+    password: str = Form(...),
+    redirect_uri: str = Form(...),
+    state: str = Form(...),
+):
+    token = f"{username}:{password}"
+    base64_token = base64.b64encode(token.encode()).decode("utf-8")
+    key = config().auth.auth_encryption_secret_key.encode()
+    encrypted = Fernet(key).encrypt(base64_token.encode()).decode()
+    new_callback_url = add_query_params(
+        redirect_uri, {"token": encrypted, "state": state}
+    )
+    return RedirectResponse(url=new_callback_url, status_code=HTTPStatus.SEE_OTHER)
+
+
+def add_query_params(url: str, params: dict):
+    url_parts = urlparse(url)
+    query_params = parse_qs(url_parts.query)
+    query_params.update(params)
+    new_query = urlencode(query_params, doseq=True)
+
+    new_url = urlunparse(
+        (
+            url_parts.scheme,
+            url_parts.netloc,
+            url_parts.path,
+            url_parts.params,
+            new_query,
+            url_parts.fragment,
+        )
+    )
+    return new_url
+
+
+basicauth_router = APIRouter(prefix="/basicauth")
+
+
+@basicauth_router.get("/basicauth/callback")
+async def basicauth_basicauth_callback(state: str, token: str):
+    try:
+        key = DefaultAuthConfig.auth_encryption_secret_key.encode()
+        decrypted = Fernet(key).decrypt(token.encode()).decode()
+        FutureStore.resolve_future(state, decrypted)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")

hyperpocket/server/auth/linkedin.py

@@ -1,5 +1,8 @@
+from cryptography.fernet import Fernet
 from fastapi import APIRouter
 from starlette.responses import HTMLResponse
+
+from hyperpocket.config import config
 from hyperpocket.futures import FutureStore
 
 linkedin_auth_router = APIRouter(prefix="/linkedin")
@@ -15,10 +18,12 @@ async def linkedin_oauth2_callback(state: str, code: str):
     return HTMLResponse(content="success")
 
 
-@linkedin_auth_router.get("/token/callback")
-async def linkedin_token_callback(state: str, token: str):
+@linkedin_auth_router.get("/basicauth/callback")
+async def linkedin_basicauth_callback(state: str, token: str):
     try:
-        FutureStore.resolve_future(state, token)
+        key = config().auth.auth_encryption_secret_key.encode()
+        decrypted = Fernet(key).decrypt(token.encode()).decode()
+        FutureStore.resolve_future(state, decrypted)
     except ValueError:
         return HTMLResponse(content="failed")
 

hyperpocket/util/convert_pydantic_to_dict.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def convert_pydantic_to_dict(data: Any):
+    if isinstance(data, BaseModel):
+        return data.model_dump()
+    elif isinstance(data, dict):
+        return {key: convert_pydantic_to_dict(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [convert_pydantic_to_dict(item) for item in data]
+
+    return data

{hyperpocket-0.5.4.dist-info → hyperpocket-0.5.6.dist-info}/METADATA

@@ -1,18 +1,19 @@
 Metadata-Version: 2.4
 Name: hyperpocket
-Version: 0.5.4
+Version: 0.5.6
 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: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1.7
+Requires-Dist: cryptography>=44.0.0
 Requires-Dist: dynaconf>=3.2.6
 Requires-Dist: fastapi>=0.115.5
 Requires-Dist: gitpython>=3.1.43
 Requires-Dist: httpx==0.27
 Requires-Dist: jinja2>=3.1.4
-Requires-Dist: multiprocess>=0.70.17
+Requires-Dist: multiprocess>=0.70.16
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: pydantic>=2.10.2
 Requires-Dist: pygithub>=2.5.0
@@ -335,6 +336,24 @@ client_secret = "" # your slack client secret
 - in this case, by putting your slack app client_id and client_secret on `.secrets.toml`, you can manage your sensitive
   data more safely.
 
+#### When using Basic Auth
+
+IMPORTANT: You should update `auth_encryption_secret_key` in `{WORKDIR}/.secret.toml` with your own secret key.
+
+```toml
+[auth]
+auth_encryption_secret_key = "<YOUR_SECRET_KEY>"
+```
+
+The secret key should be a 32 Base64 encoded string.
+
+You can generate the secret key with the following command.
+
+```shell
+pip install cryptography
+python -c 'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())'
+```
+
 #### How to integrate github OAuth app
 
 1. Follow the github documentation to create a new OAuth

{hyperpocket-0.5.4.dist-info → hyperpocket-0.5.6.dist-info}/RECORD

@@ -9,7 +9,7 @@ hyperpocket/auth/README.md,sha256=zn4QqnFZCA_4X3x8Wb6lE3OP5otYxpByZaCiUkBvaNs,11
 hyperpocket/auth/__init__.py,sha256=pO8M6SAuq0EPqi848_Iy650wqaLekx98e3RRnEAM_r0,607
 hyperpocket/auth/context.py,sha256=m-j2gDYUKBMsiakLHsu9thhM4dYyFiXP0Wp0S_iC0bU,1303
 hyperpocket/auth/handler.py,sha256=5cusl9ANEyG3gORVFjqh709txC0alw6eKtxgV6wjf6k,6683
-hyperpocket/auth/provider.py,sha256=qZGenhTsL8vqd9zmUMM52TVlmdNNOTsmLmCPmZshUNg,2103
+hyperpocket/auth/provider.py,sha256=7ATCVsM1w6F4yad4ebtabyiBIO3U2wu_FnFtE8d-0vI,2131
 hyperpocket/auth/schema.py,sha256=pl4oRTNj8PdqQg6UVPWf8ei2uYQ4DtOmmD58cVFMYQw,537
 hyperpocket/auth/activeloop/README.md,sha256=xp8n0itbY9VNt8XEvCAE4Ealvj4uf_f1uSZyWG4Q5FE,172
 hyperpocket/auth/activeloop/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -77,6 +77,12 @@ hyperpocket/auth/bamboohr/context.py,sha256=s8SNjELbLTzJZizoPAPER0Ys7axfmmqwP4pq
 hyperpocket/auth/bamboohr/token_context.py,sha256=B-DL_FO3fqWpL4Lau7-t33cIRq0EBNkH-ezyMaHkmW8,464
 hyperpocket/auth/bamboohr/token_handler.py,sha256=QwzkSxrr-tWPqd4vIRRTWwrnawbhV4ITsMO15673ev4,2958
 hyperpocket/auth/bamboohr/token_schema.py,sha256=NE6Tz-7BSi04fgoclDadjcvg4ioigy-Xu6eQQO1CGUQ,278
+hyperpocket/auth/basicauth/README.md,sha256=Sq5w_v3_JVp2k3Jaywmx_y_-ytw2Cs_oEeYveoXZVA0,564
+hyperpocket/auth/basicauth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/basicauth/basicauth_context.py,sha256=uzGIWfusl2PKJaCzZlO64KlRYk0dHqh0tVaKDQkaqFE,447
+hyperpocket/auth/basicauth/basicauth_handler.py,sha256=7j8n3fUgTM4gloKOK_x1MmbhDN_4w3UNhBf6AWQFws0,2861
+hyperpocket/auth/basicauth/basicauth_schema.py,sha256=EXJjGcVLZ4IU21XYKwkQSmbz1Dhgq6CVWDzeA7OGAeU,205
+hyperpocket/auth/basicauth/context.py,sha256=6ptACRf0ojzx0R1QvZ_Whz3SQQEJvlUkLDXElGELhxc,424
 hyperpocket/auth/bitbucket/README.md,sha256=IgKbZYRV0XREtEFuD7avgcVgtdGcl5QRUGEa8vd_Tjg,301
 hyperpocket/auth/bitbucket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/auth/bitbucket/context.py,sha256=cQhRaldutMoreNUGdVcNHQi4O5_U7V1dmJw4nm16hAM,433
@@ -218,7 +224,7 @@ hyperpocket/auth/heygen/token_schema.py,sha256=nGUQ7NBZlKHz6diuayNAtCZLXk6JQ--iR
 hyperpocket/auth/hubspot/README.md,sha256=r1f5PXUZXxFcQYqqaVCsQBauvXYP3rtxZkWFk13SSAc,315
 hyperpocket/auth/hubspot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/auth/hubspot/context.py,sha256=s4h3aaYDXpg2HJFg6H5LaV9-AKE_PoZSM7kq1XLDBC4,429
-hyperpocket/auth/hubspot/oauth2_context.py,sha256=4VpkvpU-glUHHS2h9sXbWsDKflQTyhqVdeSTeVa08ck,1135
+hyperpocket/auth/hubspot/oauth2_context.py,sha256=7tUGV_5FIjkrWIf_uWyEDBYpJOB2QNr6mIL57Q3tbXE,1062
 hyperpocket/auth/hubspot/oauth2_handler.py,sha256=oXej2p7Tj0GjOJdtf09Qo4LM67XtxtF6pUdBq8_hA1o,4866
 hyperpocket/auth/hubspot/oauth2_schema.py,sha256=7pq2nS9AS1Huxp94zQmL7_2rsJz21VuUtGLv3CIN1_I,432
 hyperpocket/auth/hubspot/token_context.py,sha256=zpbH8QFhEr-0TN9ggZIGY8UktRZWmitCzcm0K-Hl_bk,455
@@ -268,9 +274,12 @@ hyperpocket/auth/linear/token_handler.py,sha256=qfC_w_siPz_dYm3T7KJWKO1LuRazyq50
 hyperpocket/auth/linear/token_schema.py,sha256=oTy-gOZvXEmGVStgFfnNmlbkknNepOTI5KIeTQLRxus,209
 hyperpocket/auth/linkedin/README.md,sha256=_4YF9SFSYBAAe80qFYuTK0jQRtspptQMK-keu523uhM,497
 hyperpocket/auth/linkedin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/linkedin/basicauth_context.py,sha256=49aSphgH-aKz0MzpGSb8MEKvqGFBWbpkTD9vLQP7TdE,518
+hyperpocket/auth/linkedin/basicauth_handler.py,sha256=szFd8_bx197YXbkn5MmEWNHbGy4Re6Pq6L7xh0Hjr4I,2981
+hyperpocket/auth/linkedin/basicauth_schema.py,sha256=P_UQpFWd81kP0v_5d9IST9nxVlr2wGEKgzHZ-LXDwuI,221
 hyperpocket/auth/linkedin/context.py,sha256=BenS73NLL_m7AKTUb3xZD2-hS2hVckr8WB3XoEIKEo4,431
 hyperpocket/auth/linkedin/oauth2_context.py,sha256=Db75l0oEMHyTGX9rW8yrspd9JKnysT1pcCvLH15PsxU,1072
-hyperpocket/auth/linkedin/oauth2_handler.py,sha256=mGTxfArPqeG1MZKflGpItllZzFtyLL26FmeXYDt6mTc,5339
+hyperpocket/auth/linkedin/oauth2_handler.py,sha256=yBA3mEE7CQ7POD5CIduLSAKE7UeaVmiv5U5nnQE_iCQ,5340
 hyperpocket/auth/linkedin/oauth2_schema.py,sha256=c85rkrvwaJ9cNj5CD8CGkDly15g_R7DHWH_MWsohrJs,504
 hyperpocket/auth/listennotes/README.md,sha256=dzgM-crWkaUh_TmKQEsu8BFkRxueIFqZLNpoCvKQ81E,330
 hyperpocket/auth/listennotes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -486,7 +495,7 @@ hyperpocket/cli/codegen/auth/server_auth_template.py,sha256=IBmUrKTF72eEEV3igfBI
 hyperpocket/cli/codegen/tool/__init__.py,sha256=LHQ85ACCEpEV44LoOMGjYX_iUlZqoSfk0VZvorG6Eng,93
 hyperpocket/cli/codegen/tool/tool_main_template.py,sha256=VKxt-DbQ97DYtUClRZJwt3rfoidsg_CR5iIg4sH2tTg,1127
 hyperpocket/config/__init__.py,sha256=gYMHdExdPYScBB8mihSp1yJ9H-RJ8FdNz5mEFubFNAo,138
-hyperpocket/config/auth.py,sha256=OOVdaAfMva6b-Kz4iy5YpnIKjT5WgcQ17toFzHqoRPY,2173
+hyperpocket/config/auth.py,sha256=nRxCuia-Jjnlz-jpYA3-B1AovSRzBQ_GSqEtj3kwMMw,2241
 hyperpocket/config/git.py,sha256=CGbY7J1LyN4ccZr9CFGAQwwhjC9kvdU0On_nsAsZ1FQ,362
 hyperpocket/config/logger.py,sha256=RWPmuN6Rk4x3a4rendGkKLCowhs6LFlIV8rYNu2GoxM,2749
 hyperpocket/config/session.py,sha256=1ng1mARv4R_07SF5CkZWLgX9pNeXTcM0knCRw07Fpms,816
@@ -508,6 +517,7 @@ hyperpocket/server/auth/altoviz.py,sha256=36NIC0SrdTPJsSVABE5jVKf9sDyl8fbkUzlT4S
 hyperpocket/server/auth/apitoken.py,sha256=I-ZDEehzwh7WsoHBnNTW1MZDRcmzNucNVBvGNHFjaao,451
 hyperpocket/server/auth/asana.py,sha256=F1e0bOjCPdxd6ymjIxas3KqxY526qFh5dtjEERpC3XQ,709
 hyperpocket/server/auth/bamboohr.py,sha256=43NDUVZyUuF-B30WNJaLcIbIGMNnOcv4dSp0sxyAXi0,449
+hyperpocket/server/auth/basicauth.py,sha256=yUrZcAUi_VxNn0HzlsbKeFIdNefwf1w3Vuj7e7FgucY,2871
 hyperpocket/server/auth/bitbucket.py,sha256=AKWWHGbmqLg5NxsqNRLR5hxSdgvN1R6uNPw_8PPlZwY,733
 hyperpocket/server/auth/bitwarden.py,sha256=Xu_q-crU967pwr3dzNToRyeMKgs5Flgdgh0wf1B0UF8,453
 hyperpocket/server/auth/brevo.py,sha256=leFkvlxYXvtP4Z3sIHnSl96kUsvO2yL1jgB6hdNuj04,437
@@ -537,7 +547,7 @@ hyperpocket/server/auth/kraken.py,sha256=vhKhEI8NQiaMOBWbw1dROBBOCia91AYXYRozX8T
 hyperpocket/server/auth/lever.py,sha256=AJjd852iUgfbudd-ILknC7HykgaKBKlMWfEUIWZ81ok,437
 hyperpocket/server/auth/lever_sandbox.py,sha256=RrhBvEZUAfj26Nj7Ic5MQAauyMmhT9rE__tkMhmAT6Y,469
 hyperpocket/server/auth/linear.py,sha256=vUW4TEqdOYqAyx9YLJC4-dVldPTDuIPXRvoo-a89ai8,988
-hyperpocket/server/auth/linkedin.py,sha256=ia4KAJ_bxvSDmhldUZ-1PHPGiay8A_WV9KuO9Uwr9ZQ,727
+hyperpocket/server/auth/linkedin.py,sha256=iSF2Dod-ZIj7g_0j-5mIz4jhJryKAyX5xdvEPfZvH54,946
 hyperpocket/server/auth/listennotes.py,sha256=IxS90E3Z_ZDe-UyFmvEtXbpFnYAkRBnX_U35qM07rVM,461
 hyperpocket/server/auth/mailchimp.py,sha256=Bb8roxJG1zlThDDaJ6hH8pHMsY8Qb_4NAF7DjKtqK0M,733
 hyperpocket/server/auth/mem0.py,sha256=ksFs4zGhUeMsHDTQ64B1ofRLQ5aWjXelCabmkDZoMhU,433
@@ -586,6 +596,7 @@ hyperpocket/tool/function/__init__.py,sha256=n0IYvfoyoFWv76iwK2kBC-X6468dl5XyYFl
 hyperpocket/tool/function/annotation.py,sha256=qVBhjFUXY_MXysPN61FJuX4mgVZHuMJTtn0L5QCY4eg,1159
 hyperpocket/tool/function/tool.py,sha256=p7Bm9_9GAcsvzWve6n1VnIVW4EtesQdOyKmtaZCfGps,7564
 hyperpocket/util/__init__.py,sha256=7vN8c7dy7nhGhjXtSUGAsc6GIlUnuBMvXSl1yW1M4js,35
+hyperpocket/util/convert_pydantic_to_dict.py,sha256=Nevdc3adl9bbHcIqXatWnmj_HTGbTPWNGH22Cy7CCxI,399
 hyperpocket/util/extract_func_param_desc_from_docstring.py,sha256=eGDrbigmVg1zaud1q5l2WDZkYqzy56TRznNPouc8i_Y,4170
 hyperpocket/util/find_all_leaf_class_in_package.py,sha256=06n8R47BDPovxhCOnzu9GuEfeQzEbv-HdG-zfMu1gBw,533
 hyperpocket/util/find_all_subclass_in_package.py,sha256=TtEb41-nzCNhC9pgelTS6MMxLT_JNZkFPJe5z2H9yik,978
@@ -595,7 +606,7 @@ hyperpocket/util/get_objects_from_subpackage.py,sha256=4mR_S8eaJSdU68YfCkiXeIcXx
 hyperpocket/util/git_parser.py,sha256=y96nhgZXtRgA_u_0GTPo95PGkpG-n_oMIrkbckdxiR8,2496
 hyperpocket/util/json_schema_to_model.py,sha256=nc5AmnqkrdeFLELu-7_O9sEAaUaD8_KGlvIMDRobt-4,3751
 hyperpocket/util/short_hashing_str.py,sha256=ahLUT8iQr-MJVbDJXrSt0cXnnSEeJ8EU3A0PDn6e0gs,119
-hyperpocket-0.5.4.dist-info/METADATA,sha256=NUGSUVNJ8L-n0xYcCWbC7MRpoScLcNgB0uh28VHCGR0,13044
-hyperpocket-0.5.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperpocket-0.5.4.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
-hyperpocket-0.5.4.dist-info/RECORD,,
+hyperpocket-0.5.6.dist-info/METADATA,sha256=f5BQrI9LYabcT_FeNeRuWX-ZL5IY1YQa0tTJIdoXtTU,13534
+hyperpocket-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperpocket-0.5.6.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
+hyperpocket-0.5.6.dist-info/RECORD,,