hyperpocket-anthropic 0.1.3__tar.gz

hyperpocket_anthropic-0.1.3/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.1
+Name: hyperpocket-anthropic
+Version: 0.1.3
+Summary: 
+Author: moon
+Author-email: moon@vessl.ai
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: anthropic (>=0.40.0,<0.41.0)
+Requires-Dist: hyperpocket (>=0.0.1,<0.0.2)
+Description-Content-Type: text/markdown
+
+## Anthropic extensions
+
+### Get Pocket Anthropic Tool Spec
+
+```python
+import hyperpocket as pk
+from pocket_anthropic import PocketAnthropic
+
+pocket = PocketAnthropic(tools=[
+    *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+    *pk.curated_tools.LINEAR,
+    "https://github.com/my-org/some-awesome-tool"]
+)
+
+# get anthropic compatible tool specs from pocket 
+tool_specs = pocket.get_anthropic_tool_specs()
+```
+
+
+### Tool Injection
+
+```python
+import os
+
+from anthropic import Anthropic
+
+messages = [
+    {
+        "role": "user",
+        "content": "get slack message",
+    }
+]
+
+llm = Anthropic()
+response = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+```
+
+
+### Tool Call
+
+```python
+response = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+tool_result_blocks = []
+for block in response.content:
+    if block.type == "tool_use":
+        tool_result_block = pocket.invoke(block)
+        tool_result_blocks.append(tool_result_block)
+
+messages.append({"role": "user", "content": tool_result_blocks})
+
+response_after_tool_call = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+# ...
+```
+
+### Full Code
+
+```python
+import os
+
+from anthropic import Anthropic
+
+import hyperpocket as pk
+from pocket_anthropic import PocketAnthropic
+
+pocket = PocketAnthropic(tools=[
+    *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+    *pk.curated_tools.LINEAR,
+    "https://github.com/my-org/some-awesome-tool"]
+)
+
+# get anthropic compatible tool specs from pocket 
+tool_specs = pocket.get_anthropic_tool_specs()
+messages = [
+    {
+        "role": "user",
+        "content": "get slack message",
+    }
+]
+
+llm = Anthropic()
+response = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+tool_result_blocks = []
+for block in response.content:
+    if block.type == "tool_use":
+        tool_result_block = pocket.invoke(block)  # tool call by pocket
+        tool_result_blocks.append(tool_result_block)
+
+messages.append({"role": "user", "content": tool_result_blocks})
+
+response_after_tool_call = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+```
+
+
+### Examples
+
+```python
+import os
+
+from anthropic import Anthropic
+
+import hyperpocket as pk
+from pocket_anthropic import PocketAnthropic
+
+client = Anthropic()
+pocket = PocketAnthropic(
+    tools=[
+        *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+        *pk.curated_tools.LINEAR,
+        "https://github.com/my-org/some-awesome-tool"]
+)
+
+tool_specs = pocket.get_anthropic_tool_specs()
+
+messages = []
+while True:
+    print("user(q to quit) : ", end="")
+    user_input = input()
+    if user_input == "q":
+        break
+    if user_input == "":
+        continue
+
+    messages.append({"role": "user", "content": user_input})
+
+    while True:
+        response = client.messages.create(
+            model=os.getenv("ANTHROPIC_MODEL_NAME"),
+            max_tokens=500,
+            messages=messages,
+            tools=tool_specs,
+        )
+
+        messages.append({"role": "assistant", "content": response.content})
+
+        tool_result_blocks = []
+        for block in response.content:
+            if block.type == "text":
+                print("[ai] response : ", block.text)
+
+            elif block.type == "tool_use":
+                tool_result_block = pocket.invoke(block)
+                tool_result_blocks.append(tool_result_block)
+
+                print("[tool] response : ", tool_result_block["content"])
+
+        messages.append({"role": "user", "content": tool_result_blocks})
+
+        if response.stop_reason != "tool_use":
+            break
+```

hyperpocket_anthropic-0.1.3/README.md

@@ -0,0 +1,179 @@
+## Anthropic extensions
+
+### Get Pocket Anthropic Tool Spec
+
+```python
+import hyperpocket as pk
+from pocket_anthropic import PocketAnthropic
+
+pocket = PocketAnthropic(tools=[
+    *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+    *pk.curated_tools.LINEAR,
+    "https://github.com/my-org/some-awesome-tool"]
+)
+
+# get anthropic compatible tool specs from pocket 
+tool_specs = pocket.get_anthropic_tool_specs()
+```
+
+
+### Tool Injection
+
+```python
+import os
+
+from anthropic import Anthropic
+
+messages = [
+    {
+        "role": "user",
+        "content": "get slack message",
+    }
+]
+
+llm = Anthropic()
+response = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+```
+
+
+### Tool Call
+
+```python
+response = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+tool_result_blocks = []
+for block in response.content:
+    if block.type == "tool_use":
+        tool_result_block = pocket.invoke(block)
+        tool_result_blocks.append(tool_result_block)
+
+messages.append({"role": "user", "content": tool_result_blocks})
+
+response_after_tool_call = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+# ...
+```
+
+### Full Code
+
+```python
+import os
+
+from anthropic import Anthropic
+
+import hyperpocket as pk
+from pocket_anthropic import PocketAnthropic
+
+pocket = PocketAnthropic(tools=[
+    *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+    *pk.curated_tools.LINEAR,
+    "https://github.com/my-org/some-awesome-tool"]
+)
+
+# get anthropic compatible tool specs from pocket 
+tool_specs = pocket.get_anthropic_tool_specs()
+messages = [
+    {
+        "role": "user",
+        "content": "get slack message",
+    }
+]
+
+llm = Anthropic()
+response = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+tool_result_blocks = []
+for block in response.content:
+    if block.type == "tool_use":
+        tool_result_block = pocket.invoke(block)  # tool call by pocket
+        tool_result_blocks.append(tool_result_block)
+
+messages.append({"role": "user", "content": tool_result_blocks})
+
+response_after_tool_call = llm.messages.create(
+    model=os.getenv("ANTHROPIC_MODEL_NAME"),
+    max_tokens=500,
+    messages=messages,
+    tools=tool_specs,  # pass the tool specs as an tools argument
+)
+
+```
+
+
+### Examples
+
+```python
+import os
+
+from anthropic import Anthropic
+
+import hyperpocket as pk
+from pocket_anthropic import PocketAnthropic
+
+client = Anthropic()
+pocket = PocketAnthropic(
+    tools=[
+        *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+        *pk.curated_tools.LINEAR,
+        "https://github.com/my-org/some-awesome-tool"]
+)
+
+tool_specs = pocket.get_anthropic_tool_specs()
+
+messages = []
+while True:
+    print("user(q to quit) : ", end="")
+    user_input = input()
+    if user_input == "q":
+        break
+    if user_input == "":
+        continue
+
+    messages.append({"role": "user", "content": user_input})
+
+    while True:
+        response = client.messages.create(
+            model=os.getenv("ANTHROPIC_MODEL_NAME"),
+            max_tokens=500,
+            messages=messages,
+            tools=tool_specs,
+        )
+
+        messages.append({"role": "assistant", "content": response.content})
+
+        tool_result_blocks = []
+        for block in response.content:
+            if block.type == "text":
+                print("[ai] response : ", block.text)
+
+            elif block.type == "tool_use":
+                tool_result_block = pocket.invoke(block)
+                tool_result_blocks.append(tool_result_block)
+
+                print("[tool] response : ", tool_result_block["content"])
+
+        messages.append({"role": "user", "content": tool_result_blocks})
+
+        if response.stop_reason != "tool_use":
+            break
+```

hyperpocket_anthropic-0.1.3/hyperpocket_anthropic/__init__.py

@@ -0,0 +1,3 @@
+from hyperpocket_anthropic.pocket_anthropic import PocketAnthropic
+
+__all__ = ["PocketAnthropic"]

hyperpocket_anthropic-0.1.3/hyperpocket_anthropic/pocket_anthropic.py

@@ -0,0 +1,77 @@
+import json
+from typing import List
+
+try:
+    from anthropic.types import ToolResultBlockParam, ToolUseBlock
+except ImportError:
+    raise ImportError("You need to install anthropic to use pocket anthropic.")
+
+from hyperpocket import Pocket
+from hyperpocket.tool import Tool
+
+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)
+        result, interrupted = self.invoke_with_state(
+            tool_use_block.name, body=body, **kwargs
+        )
+        say = result
+        if interrupted:
+            say = (
+                f"{say}\n\nThe tool execution interrupted. Please talk to me to resume."
+            )
+
+        tool_result_block = ToolResultBlockParam(
+            tool_use_id=tool_use_block.id, type="tool_result", content=say
+        )
+
+        return tool_result_block
+
+    async def ainvoke(
+            self, tool_use_block: ToolUseBlock, **kwargs
+    ) -> ToolResultBlockParam:
+        body = self.parse_input(tool_use_block)
+        result, interrupted = await self.ainvoke_with_state(
+            tool_use_block.name, body=body, **kwargs
+        )
+        say = result
+
+        if interrupted:
+            say = (
+                f"{say}\n\nThe tool execution interrupted. Please talk to me to resume."
+            )
+
+        tool_result_block = ToolResultBlockParam(
+            tool_use_id=tool_use_block.id, type="tool_result", content=say
+        )
+
+        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) -> List[dict]:
+        specs = []
+        for tool in self.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)
+        return spec

hyperpocket_anthropic-0.1.3/hyperpocket_anthropic/util/__init__.py

@@ -0,0 +1,3 @@
+from hyperpocket_anthropic.util.tool_to_anthropic_spec import tool_to_anthropic_spec
+
+__all__ = ["tool_to_anthropic_spec"]

hyperpocket_anthropic-0.1.3/hyperpocket_anthropic/util/tool_to_anthropic_spec.py

@@ -0,0 +1,22 @@
+from hyperpocket.tool import Tool
+from hyperpocket.util.flatten_json_schema import flatten_json_schema
+
+
+def tool_to_anthropic_spec(tool: Tool) -> dict:
+    name = tool.name
+    description = tool.description
+    arg_schema = tool.schema_model()
+    json_schema = flatten_json_schema(arg_schema.model_json_schema())
+
+    anthropic_spec = {
+        "name": name,
+        "description": description.strip(),
+        "input_schema": {
+            "type": json_schema["type"],
+            "properties": json_schema["properties"],
+            "required": json_schema.get("required", []),
+            "title": json_schema.get("title", ""),
+        },
+    }
+
+    return anthropic_spec

hyperpocket_anthropic-0.1.3/pyproject.toml

@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "hyperpocket-anthropic"
+version = "0.1.3"
+description = ""
+authors = ["moon <moon@vessl.ai>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+anthropic = "^0.40.0"
+hyperpocket = "^0.0.1"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"