hyperpocket-llamaindex 0.1.8__tar.gz → 0.1.10__tar.gz

{hyperpocket_llamaindex-0.1.8 → hyperpocket_llamaindex-0.1.10}/.gitignore

@@ -14,6 +14,7 @@ __pycache__/
 build/
 develop-eggs/
 dist/
+!tools/**/dist/
 downloads/
 eggs/
 .eggs/

{hyperpocket_llamaindex-0.1.8 → hyperpocket_llamaindex-0.1.10}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: hyperpocket-llamaindex
-Version: 0.1.8
-Author-email: moon <moon@vessl.ai>
+Version: 0.1.10
+Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: hyperpocket>=0.0.3
 Requires-Dist: llama-index>=0.12.5

{hyperpocket_llamaindex-0.1.8 → hyperpocket_llamaindex-0.1.10}/hyperpocket_llamaindex/pocket_llamaindex.py

@@ -1,4 +1,6 @@
-from typing import List, Any
+from typing import List, Optional
+
+from pydantic import BaseModel
 
 try:
     from llama_index.core.tools import FunctionTool, BaseTool, ToolMetadata
@@ -12,12 +14,27 @@ from hyperpocket.tool import Tool
 
 
 class PocketLlamaindex(Pocket):
-    def get_tools(self) -> List[BaseTool]:
+    def get_tools(self, use_profile: Optional[bool] = None) -> List[BaseTool]:
+        if use_profile is not None:
+            self.use_profile = use_profile
+
         tools = [self.get_tool(pk) for pk in self.core.tools.values()]
         return tools
 
     def get_tool(self, pocket_tool: Tool) -> BaseTool:
-        def _invoke(body: Any, thread_id: str = 'default', profile: str = 'default', **kwargs) -> str:
+        def _invoke(**kwargs) -> str:
+            if self.use_profile:
+                body = kwargs["body"]
+                thread_id = kwargs.pop("thread_id", "default")
+                profile = kwargs.pop("profile", "default")
+            else:
+                body = kwargs
+                thread_id = "default"
+                profile = "default"
+
+            if isinstance(body, BaseModel):
+                body = body.model_dump()
+
             result, interrupted = self.invoke_with_state(pocket_tool.name, body=body, thread_id=thread_id,
                                                          profile=profile, **kwargs)
             say = result
@@ -25,7 +42,19 @@ class PocketLlamaindex(Pocket):
                 say = f'{say}\n\nThe tool execution interrupted. Please talk to me to resume.'
             return say
 
-        async def _ainvoke(body: Any, thread_id: str = 'default', profile: str = 'default', **kwargs) -> str:
+        async def _ainvoke(**kwargs) -> str:
+            if self.use_profile:
+                body = kwargs["body"]
+                thread_id = kwargs.pop("thread_id", "default")
+                profile = kwargs.pop("profile", "default")
+            else:
+                body = kwargs
+                thread_id = "default"
+                profile = "default"
+
+            if isinstance(body, BaseModel):
+                body = body.model_dump()
+
             result, interrupted = await self.ainvoke_with_state(pocket_tool.name, body=body,
                                                                 thread_id=thread_id, profile=profile, **kwargs)
             say = result
@@ -37,8 +66,8 @@ class PocketLlamaindex(Pocket):
             fn=_invoke,
             async_fn=_ainvoke,
             tool_metadata=ToolMetadata(
-                description=pocket_tool.description,
                 name=pocket_tool.name,
-                fn_schema=pocket_tool.schema_model(),
+                description=pocket_tool.get_description(use_profile=self.use_profile),
+                fn_schema=pocket_tool.schema_model(use_profile=self.use_profile),
             )
         )

{hyperpocket_llamaindex-0.1.8 → hyperpocket_llamaindex-0.1.10}/pyproject.toml

@@ -1,9 +1,9 @@
 
 [project]
 name = "hyperpocket-llamaindex"
-version = "0.1.8"
+version = "0.1.10"
 description = ""
-authors = [{ name = "moon", email = "moon@vessl.ai" }]
+authors = [{ name = "Hyperpocket Team", email = "hyperpocket@vessl.ai" }]
 requires-python = ">=3.10"
 readme = "README.md"
 dependencies = ["llama-index>=0.12.5", "hyperpocket>=0.0.3"]

hyperpocket_llamaindex-0.1.10/tests/test_pocket_llamaindex_no_profile.py

@@ -0,0 +1,137 @@
+import ast
+import json
+from unittest.async_case import IsolatedAsyncioTestCase
+
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+from pydantic import BaseModel
+
+from hyperpocket.config import config, secret
+from hyperpocket.tool import from_git
+from hyperpocket_llamaindex import PocketLlamaindex
+
+
+class TestPocketLlamaindexNoProfile(IsolatedAsyncioTestCase):
+
+    async def asyncSetUp(self):
+        config.public_server_port = "https"
+        config.public_hostname = "localhost"
+        config.public_server_port = 8001
+        config.internal_server_port = 8000
+        config.enable_local_callback_proxy = True
+
+        self.pocket = PocketLlamaindex(
+            tools=[
+                from_git("https://github.com/vessl-ai/hyperawesometools", "main",
+                         "managed-tools/none/simple-echo-tool"),
+                self.add,
+                self.sub_pydantic_args
+            ],
+            use_profile=False
+        )
+
+        self.llm = OpenAI(model="gpt-4o", api_key=secret["OPENAI_API_KEY"])
+
+    async def asyncTearDown(self):
+        self.pocket._teardown_server()
+
+    async def test_agent_no_profile(self):
+        # given
+        agent = OpenAIAgent.from_tools(
+            tools=self.pocket.get_tools(),
+            llm=OpenAI(model="gpt-4o", api_key=secret["OPENAI_API_KEY"]),
+            verbose=True
+        )
+
+        # when
+        agent.query("add 1, 2")
+        agent.query("sub 1, 2")
+        agent.query("echo 'hello world'")
+
+    async def test_function_tool_no_profile(self):
+        # when
+        response = self.llm.chat_with_tools(user_msg="add 1, 2", tools=self.pocket.get_tools(), verbose=True)
+        message = response.message
+        tool_calls = message.additional_kwargs["tool_calls"]
+
+        tool_name = tool_calls[0].function.name
+        args = tool_calls[0].function.arguments
+        args = json.loads(args)
+
+        result = await self.pocket.ainvoke(tool_name=tool_name, body=args)
+
+        # then
+        self.assertEqual(tool_name, "add")
+        self.assertEqual(args, {
+            "a": 1,
+            "b": 2,
+        })
+        self.assertEqual(result, '3')
+
+    async def test_pydantic_function_tool_no_profile(self):
+        # when
+        response = self.llm.chat_with_tools(user_msg="sub 1, 2", tools=self.pocket.get_tools(), verbose=True)
+        tool_calls = response.message.additional_kwargs["tool_calls"]
+
+        tool_name = tool_calls[0].function.name
+        args = tool_calls[0].function.arguments
+        args = json.loads(args)
+
+        result = await self.pocket.ainvoke(tool_name=tool_name, body=args)
+
+        # then
+        self.assertEqual(tool_name, "sub_pydantic_args")
+        self.assertEqual(args, {
+            "a": {"first": 1},
+            "b": {"second": 2},
+        })
+        self.assertEqual(result, '-1')
+
+    async def test_wasm_tool_no_profile(self):
+        # when
+        response = self.llm.chat_with_tools(user_msg="echo 'hello world'", tools=self.pocket.get_tools(), verbose=True)
+        tool_calls = response.message.additional_kwargs["tool_calls"]
+
+        tool_name = tool_calls[0].function.name
+        args = tool_calls[0].function.arguments
+        args = json.loads(args)
+
+        result = await self.pocket.ainvoke(tool_name=tool_name, body=args)
+        output = ast.literal_eval(result)
+
+        # then
+        self.assertEqual(tool_name, "simple_echo_text")
+        self.assertEqual(args, {
+            "text": "hello world"
+        })
+        self.assertTrue(output["stdout"].startswith("echo message : hello world"))
+
+    @staticmethod
+    def add(a: int, b: int) -> int:
+        """
+        Add two numbers
+
+        Args:
+            a(int): first number
+            b(int): second number
+
+        """
+
+        return a + b
+
+    class FirstNumber(BaseModel):
+        first: int
+
+    class SecondNumber(BaseModel):
+        second: int
+
+    @staticmethod
+    def sub_pydantic_args(a: FirstNumber, b: SecondNumber):
+        """
+        sub two numbers
+
+        Args:
+            a(FirstNumber): first number
+            b(SecondNumber): second number
+        """
+        return a.first - b.second

hyperpocket_llamaindex-0.1.8/tests/test_pocket_llamaindex.py → hyperpocket_llamaindex-0.1.10/tests/test_pocket_llamaindex_use_profile.py

@@ -1,3 +1,4 @@
+import ast
 import json
 from unittest.async_case import IsolatedAsyncioTestCase
 
@@ -10,7 +11,7 @@ from hyperpocket.tool import from_git
 from hyperpocket_llamaindex import PocketLlamaindex
 
 
-class TestPocketLlamaindex(IsolatedAsyncioTestCase):
+class TestPocketLlamaindexUseProfile(IsolatedAsyncioTestCase):
 
     async def asyncSetUp(self):
         config.public_server_port = "https"
@@ -21,22 +22,31 @@ class TestPocketLlamaindex(IsolatedAsyncioTestCase):
 
         self.pocket = PocketLlamaindex(
             tools=[
-                from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/simple-echo-tool"),
+                from_git("https://github.com/vessl-ai/hyperawesometools", "main",
+                         "managed-tools/none/simple-echo-tool"),
                 self.add,
                 self.sub_pydantic_args
             ],
+            use_profile=True
         )
 
-        self.agent = OpenAIAgent.from_tools(
+        self.llm = OpenAI(model="gpt-4o", api_key=secret["OPENAI_API_KEY"])
+
+    async def asyncTearDown(self):
+        self.pocket._teardown_server()
+
+    async def test_agent_use_profile(self):
+        # given
+        agent = OpenAIAgent.from_tools(
             tools=self.pocket.get_tools(),
             llm=OpenAI(model="gpt-4o", api_key=secret["OPENAI_API_KEY"]),
             verbose=True
         )
 
-        self.llm = OpenAI(model="gpt-4o", api_key=secret["OPENAI_API_KEY"])
-
-    async def asyncTearDown(self):
-        self.pocket._teardown_server()
+        # when
+        agent.query("add 1, 2")
+        agent.query("sub 1, 2")
+        agent.query("echo 'hello world'")
 
     async def test_function_tool(self):
         # when
@@ -87,13 +97,14 @@ class TestPocketLlamaindex(IsolatedAsyncioTestCase):
         args = json.loads(args)
 
         result = await self.pocket.ainvoke(tool_name=tool_name, **args)
+        output = ast.literal_eval(result)
 
         # then
         self.assertEqual(tool_name, "simple_echo_text")
         self.assertEqual(args["body"], {
             "text": "hello world"
         })
-        self.assertTrue(result.startswith("echo message : hello world"))
+        self.assertTrue(output["stdout"].startswith("echo message : hello world"))
 
     @staticmethod
     def add(a: int, b: int) -> int: