hyperpocket-anthropic 0.1.8__tar.gz → 0.1.9__tar.gz

{hyperpocket_anthropic-0.1.8 → hyperpocket_anthropic-0.1.9}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: hyperpocket-anthropic
-Version: 0.1.8
-Author-email: moon <moon@vessl.ai>
+Version: 0.1.9
+Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: anthropic>=0.40.0
 Requires-Dist: hyperpocket>=0.0.3

{hyperpocket_anthropic-0.1.8 → hyperpocket_anthropic-0.1.9}/hyperpocket_anthropic/pocket_anthropic.py

@@ -1,5 +1,7 @@
 import json
-from typing import List
+from typing import List, Optional
+
+from pydantic import BaseModel
 
 try:
     from anthropic.types import ToolResultBlockParam, ToolUseBlock
@@ -14,9 +16,27 @@ from hyperpocket_anthropic.util import tool_to_anthropic_spec
 
 class PocketAnthropic(Pocket):
     def invoke(self, tool_use_block: ToolUseBlock, **kwargs) -> ToolResultBlockParam:
-        body = self.parse_input(tool_use_block)
+        if isinstance(tool_use_block.input, str):
+            arg = json.loads(tool_use_block.input)
+        else:
+            arg = tool_use_block.input
+
+        if self.use_profile:
+            body = arg.pop("body")
+            thread_id = arg.pop("thread_id", "default")
+            profile = arg.pop("profile", "default")
+        else:
+            body = arg
+            thread_id = "default"
+            profile = "default"
+
+        if isinstance(body, BaseModel):
+            body = body.model_dump()
+        elif isinstance(body, str):
+            body = json.loads(body)
+
         result, interrupted = self.invoke_with_state(
-            tool_use_block.name, body=body, **kwargs
+            tool_use_block.name, body=body, thread_id=thread_id, profile=profile, **kwargs
         )
         say = result
         if interrupted:
@@ -33,9 +53,27 @@ class PocketAnthropic(Pocket):
     async def ainvoke(
             self, tool_use_block: ToolUseBlock, **kwargs
     ) -> ToolResultBlockParam:
-        body = self.parse_input(tool_use_block)
+        if isinstance(tool_use_block.input, str):
+            arg = json.loads(tool_use_block.input)
+        else:
+            arg = tool_use_block.input
+
+        if self.use_profile:
+            body = arg.pop("body")
+            thread_id = arg.pop("thread_id", "default")
+            profile = arg.pop("profile", "default")
+        else:
+            body = arg
+            thread_id = "default"
+            profile = "default"
+
+        if isinstance(body, BaseModel):
+            body = body.model_dump()
+        elif isinstance(body, str):
+            body = json.loads(body)
+
         result, interrupted = await self.ainvoke_with_state(
-            tool_use_block.name, body=body, **kwargs
+            tool_use_block.name, body=body, thread_id=thread_id, profile=profile, **kwargs
         )
         say = result
 
@@ -50,28 +88,16 @@ class PocketAnthropic(Pocket):
 
         return tool_result_block
 
-    @staticmethod
-    def parse_input(tool_use_block):
-        if isinstance(tool_use_block.input, str):
-            arg = json.loads(tool_use_block.input)
-            body = arg["body"]
-        else:
-            arg = tool_use_block.input
-            body = arg["body"]
-
-        if isinstance(body, str):
-            body = json.loads(body)
-
-        return body
+    def get_anthropic_tool_specs(self, use_profile: Optional[bool] = None) -> List[dict]:
+        if use_profile is not None:
+            self.use_profile = use_profile
 
-    def get_anthropic_tool_specs(self) -> List[dict]:
         specs = []
         for tool in self.core.tools.values():
             spec = self.get_anthropic_tool_spec(tool)
             specs.append(spec)
         return specs
 
-    @staticmethod
-    def get_anthropic_tool_spec(tool: Tool) -> dict:
-        spec = tool_to_anthropic_spec(tool)
+    def get_anthropic_tool_spec(self, tool: Tool) -> dict:
+        spec = tool_to_anthropic_spec(tool, use_profile=self.use_profile)
         return spec

{hyperpocket_anthropic-0.1.8 → hyperpocket_anthropic-0.1.9}/hyperpocket_anthropic/util/tool_to_anthropic_spec.py

@@ -2,10 +2,10 @@ from hyperpocket.tool import Tool
 from hyperpocket.util.flatten_json_schema import flatten_json_schema
 
 
-def tool_to_anthropic_spec(tool: Tool) -> dict:
+def tool_to_anthropic_spec(tool: Tool, use_profile: bool) -> dict:
     name = tool.name
-    description = tool.description
-    arg_schema = tool.schema_model()
+    description = tool.get_description(use_profile=use_profile)
+    arg_schema = tool.schema_model(use_profile=use_profile)
     json_schema = flatten_json_schema(arg_schema.model_json_schema())
 
     anthropic_spec = {

{hyperpocket_anthropic-0.1.8 → hyperpocket_anthropic-0.1.9}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "hyperpocket-anthropic"
-version = "0.1.8"
+version = "0.1.9"
 description = ""
-authors = [{ name = "moon", email = "moon@vessl.ai" }]
+authors = [{ name = "Hyperpocket Team", email = "hyperpocket@vessl.ai" }]
 requires-python = ">=3.10"
 readme = "README.md"
 dependencies = ["anthropic>=0.40.0", "hyperpocket>=0.0.3"]

hyperpocket_anthropic-0.1.9/tests/test_pocket_anthropic_no_profile.py

@@ -0,0 +1,148 @@
+import ast
+from unittest.async_case import IsolatedAsyncioTestCase
+
+from anthropic import Anthropic
+from pydantic import BaseModel
+
+from hyperpocket.config import config, secret
+from hyperpocket.tool import from_git
+from hyperpocket_anthropic import PocketAnthropic
+
+
+class TestPocketAnthropicNoProfile(IsolatedAsyncioTestCase):
+    @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
+
+    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 = PocketAnthropic(
+            tools=[
+                from_git("https://github.com/vessl-ai/hyperawesometools", "main",
+                         "managed-tools/none/simple-echo-tool"),
+                self.add,
+                self.sub_pydantic_args
+            ],
+        )
+        self.tool_specs_no_profile = self.pocket.get_anthropic_tool_specs(use_profile=False)
+        self.client = Anthropic(api_key=secret["ANTHROPIC_API_KEY"])
+
+    async def asyncTearDown(self):
+        self.pocket._teardown_server()
+
+    def test_get_tools_from_pocket_no_profile(self):
+        # given
+        pocket = PocketAnthropic(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"),
+        ])
+
+        # when
+        specs = pocket.get_anthropic_tool_specs()
+        get_tool, send_tool = specs[0], specs[1]
+
+        # then
+        self.assertIsInstance(get_tool, dict)
+        self.assertEqual(get_tool["name"], 'slack_get_messages')
+        self.assertTrue("channel" in get_tool["input_schema"]["properties"])
+        self.assertTrue("limit" in get_tool["input_schema"]["properties"])
+
+        self.assertIsInstance(send_tool, dict)
+        self.assertEqual(send_tool["name"], 'slack_send_messages')
+        self.assertTrue("channel" in send_tool["input_schema"]["properties"])
+        self.assertTrue("text" in send_tool["input_schema"]["properties"])
+
+    async def test_function_tool_no_profile(self):
+        response = self.client.messages.create(
+            model="claude-3-5-haiku-latest",
+            max_tokens=500,
+            messages=[{
+                "role": "user",
+                "content": "add 1, 2"
+            }],
+            tools=self.tool_specs_no_profile,
+        )
+
+        tool_result_block = None
+        for block in response.content:
+            if block.type == "tool_use":
+                tool_result_block = await self.pocket.ainvoke(block)
+
+        # then
+        self.assertEqual(response.stop_reason, "tool_use")
+        self.assertIsNotNone(tool_result_block)
+        self.assertEqual(tool_result_block["content"], "3")
+
+    async def test_pydantic_function_tool_no_profile(self):
+        response = self.client.messages.create(
+            model="claude-3-5-haiku-latest",
+            max_tokens=500,
+            messages=[{
+                "role": "user",
+                "content": "sub 1, 2"
+            }],
+            tools=self.tool_specs_no_profile,
+        )
+
+        tool_result_block = None
+        for block in response.content:
+            if block.type == "tool_use":
+                tool_result_block = await self.pocket.ainvoke(block)
+
+        # then
+        self.assertEqual(response.stop_reason, "tool_use")
+        self.assertIsNotNone(tool_result_block)
+        self.assertEqual(tool_result_block["content"], "-1")
+
+    async def test_wasm_tool_no_profile(self):
+        response = self.client.messages.create(
+            model="claude-3-5-haiku-latest",
+            max_tokens=500,
+            messages=[{
+                "role": "user",
+                "content": "echo 'hello world'"
+            }],
+            tools=self.tool_specs_no_profile,
+        )
+
+        tool_result_block = None
+        for block in response.content:
+            if block.type == "tool_use":
+                tool_result_block = await self.pocket.ainvoke(block)
+        output = ast.literal_eval(tool_result_block["content"])
+
+        # then
+        self.assertEqual(response.stop_reason, "tool_use")
+        self.assertIsNotNone(tool_result_block)
+        self.assertTrue(output["stdout"].startswith("echo message : hello world"))

hyperpocket_anthropic-0.1.8/tests/test_pocket_anthropic.py → hyperpocket_anthropic-0.1.9/tests/test_pocket_anthropic_use_profile.py

@@ -1,3 +1,4 @@
+import ast
 from unittest.async_case import IsolatedAsyncioTestCase
 
 from anthropic import Anthropic
@@ -8,7 +9,7 @@ from hyperpocket.tool import from_git
 from hyperpocket_anthropic import PocketAnthropic
 
 
-class TestPocketAnthropic(IsolatedAsyncioTestCase):
+class TestPocketAnthropicUseProfile(IsolatedAsyncioTestCase):
     @staticmethod
     def add(a: int, b: int) -> int:
         """
@@ -48,18 +49,19 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
 
         self.pocket = PocketAnthropic(
             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
             ],
         )
-        self.tool_specs = self.pocket.get_anthropic_tool_specs()
+        self.tool_specs_use_profile = self.pocket.get_anthropic_tool_specs(use_profile=True)
         self.client = Anthropic(api_key=secret["ANTHROPIC_API_KEY"])
 
     async def asyncTearDown(self):
         self.pocket._teardown_server()
 
-    def test_get_tools_from_pocket(self):
+    def test_get_tools_from_pocket_use_profile(self):
         # given
         pocket = PocketAnthropic(tools=[
             from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/slack/get-message"),
@@ -67,7 +69,7 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
         ])
 
         # when
-        specs = pocket.get_anthropic_tool_specs()
+        specs = pocket.get_anthropic_tool_specs(use_profile=True)
         get_tool, send_tool = specs[0], specs[1]
 
         # then
@@ -83,7 +85,8 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
         self.assertTrue("channel" in send_tool["input_schema"]["properties"]["body"]["properties"])
         self.assertTrue("text" in send_tool["input_schema"]["properties"]["body"]["properties"])
 
-    async def test_function_tool(self):
+
+    async def test_function_tool_use_profile(self):
         response = self.client.messages.create(
             model="claude-3-5-haiku-latest",
             max_tokens=500,
@@ -91,7 +94,7 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
                 "role": "user",
                 "content": "add 1, 2"
             }],
-            tools=self.tool_specs,
+            tools=self.tool_specs_use_profile,
         )
 
         tool_result_block = None
@@ -104,7 +107,8 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
         self.assertIsNotNone(tool_result_block)
         self.assertEqual(tool_result_block["content"], "3")
 
-    async def test_pydantic_function_tool(self):
+
+    async def test_pydantic_function_tool_use_profile(self):
         response = self.client.messages.create(
             model="claude-3-5-haiku-latest",
             max_tokens=500,
@@ -112,7 +116,7 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
                 "role": "user",
                 "content": "sub 1, 2"
             }],
-            tools=self.tool_specs,
+            tools=self.tool_specs_use_profile,
         )
 
         tool_result_block = None
@@ -125,7 +129,8 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
         self.assertIsNotNone(tool_result_block)
         self.assertEqual(tool_result_block["content"], "-1")
 
-    async def test_wasm_tool(self):
+
+    async def test_wasm_tool_use_profile(self):
         response = self.client.messages.create(
             model="claude-3-5-haiku-latest",
             max_tokens=500,
@@ -133,15 +138,17 @@ class TestPocketAnthropic(IsolatedAsyncioTestCase):
                 "role": "user",
                 "content": "echo 'hello world'"
             }],
-            tools=self.tool_specs,
+            tools=self.tool_specs_use_profile,
         )
 
         tool_result_block = None
         for block in response.content:
             if block.type == "tool_use":
                 tool_result_block = await self.pocket.ainvoke(block)
+        output = ast.literal_eval(tool_result_block["content"])
 
         # then
         self.assertEqual(response.stop_reason, "tool_use")
         self.assertIsNotNone(tool_result_block)
-        self.assertTrue(tool_result_block["content"].startswith("echo message : hello world"))
+        self.assertTrue(output["stdout"].startswith("echo message : hello world"))
+