Merge pull request #1 from toolhouseai/feature/local_runner

Feature/local runner

Author: pulphix

examples/sample_run_local_tools.py

@@ -0,0 +1,64 @@
+"""Antropic Sample"""
+import os
+from typing import List
+
+from dotenv import load_dotenv
+from anthropic import Anthropic
+from anthropic.types import TextBlock
+from toolhouse import Toolhouse, Provider
+
+load_dotenv()
+
+TOKEN = os.getenv("ANTHROPIC_KEY")
+TH_TOKEN = os.getenv("TOOLHOUSE_BEARER_TOKEN")
+
+local_tools = [
+    {
+        'name': 'hello',
+        'description': 'The user receive a customized hello message from a city and return it to the user', 
+        'input_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'city': {'type': 'string', 'description': 'The city where you are from'}
+                        },
+                    'required': ['city']
+                    }
+                }
+    ]
+
+client = Anthropic(api_key=TOKEN)
+
+th = Toolhouse(access_token=TH_TOKEN, provider=Provider.ANTHROPIC)
+th.set_metadata("id", "fabio")
+th.set_metadata("timezone", 5)
+
+
+@th.register_local_tool("hello")
+def whatever(city: str):
+    """Return Local Time"""
+    return f"Hello from {city}!!!"
+
+
+messages: List = [{
+    "role": "user",
+    "content":
+        "Can I get an hello from Rome?"
+    }]
+
+response = client.messages.create(
+    model="claude-3-5-sonnet-20240620",
+    max_tokens=1024,
+    tools=th.get_tools() + local_tools,
+    messages=messages
+)
+
+messages += th.run_tools(response)
+
+response = client.messages.create(
+            model="claude-3-5-sonnet-20240620",
+            max_tokens=1024,
+            tools=th.get_tools() + local_tools,
+            messages=messages
+        )
+if isinstance(response.content[0], TextBlock):
+    print(response.content[0].text)

examples/sample_run_local_tools_openai.py

@@ -0,0 +1,60 @@
+"""Antropic Sample"""
+import os
+from typing import List
+from dotenv import load_dotenv
+from openai import OpenAI
+from toolhouse import Toolhouse
+load_dotenv()
+
+TOKEN = os.getenv("OPENAI_KEY")
+TH_TOKEN = os.getenv("TOOLHOUSE_BEARER_TOKEN")
+
+
+local_tools = [
+    {'type': 'function',
+     'function':
+         {
+             'name': 'hello',
+             'description': 'The user receive a customized hello message from a city and return it to the user', 
+             'parameters': {
+                 'type': 'object',
+                 'properties': {
+                     'city': {'type': 'string', 'description': 'The city where you are from'}
+                 }},
+             'required': ['city']
+         }}]
+
+th = Toolhouse(access_token=TH_TOKEN, provider="openai")
+th.set_metadata("id", "fabio")
+th.set_metadata("timezone", 5)
+
+
+@th.register_local_tool("hello")
+def whatever(city: str):
+    """Return Local Time"""
+    return f"Hello from {city}!!!"
+
+
+client = OpenAI(api_key=TOKEN)
+
+messages: List = [{
+    "role": "user",
+    "content":
+        "Can I get an hello from Rome?"
+    }]
+
+response = client.chat.completions.create(
+    model='gpt-4o',
+    messages=messages,
+    tools=th.get_tools() + local_tools
+)
+
+messages += th.run_tools(response)
+
+response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            tools=th.get_tools() + local_tools
+        )
+
+print(response.choices[0].message.content)

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "toolhouse"
-version = "1.0.0"
+version = "1.1.0"
 license = {file = "LICENSE"}
 authors = [
 	{ name = "Toolhouse Technologies", email = "[email protected]" },

src/toolhouse/__init__.py

@@ -1,7 +1,7 @@
 # This file was generated by liblab | https://liblab.com/
 # flake8: noqa
 from .sdk import Toolhouse
-from ._exceptions import ToolhouseError
+from .exceptions import ToolhouseError
 from .net.environment import Environment
 from .models.Provider import Provider
 from .models import stream_to_chat_completion, OpenAIStream

src/toolhouse/_exceptions.py src/toolhouse/exceptions.py

@@ -0,0 +1,30 @@
+from typing import Literal
+from pydantic import BaseModel
+
+
+class AnthropicToolResponse(BaseModel):
+    """Represents the results of a tool call for Anthropic."""
+
+    tool_use_id: str
+    """The ID of the tool call."""
+
+    content: str
+    """Result of the tool call."""
+
+    type: Literal["tool_result"]
+    """The type of tool call the output is required for."""
+
+
+class OpenAIToolResponse(BaseModel):
+    """Represents the results of a tool call for OpenAI."""
+
+    role: Literal['tool']
+
+    tool_call_id: str
+    """The ID of the tool call."""
+
+    name: str
+    """tool_function_name"""
+
+    content: str
+    """Result of the tool call."""

src/toolhouse/models/RunLocalTools.py

@@ -0,0 +1,4 @@
+"""Tool Configuration Models"""
+from .openai import Tools as OpenAITools
+from .anthropic import Tools as AnthropicTools
+from .toolhouse import Tools as ToolhouseTools

src/toolhouse/models/tools_models/__init__.py

@@ -0,0 +1,30 @@
+from typing import Literal, List, Dict
+from pydantic import BaseModel
+
+
+ArgumentType = Literal["string", "number", "integer", "object", "array", "boolean"]
+
+
+class Property(BaseModel):
+    """Tool Property"""
+    type: ArgumentType
+    description: str
+
+
+class InputSchema(BaseModel):
+    """InputSchema"""
+    type: Literal['object']
+    properties: Dict[str, Property]
+    required: List[str]
+
+
+class Tool(BaseModel):
+    """Anthropic Tools"""
+    name: str
+    description: str
+    input_schema: InputSchema
+
+
+class Tools(BaseModel):
+    """ToolHouse"""
+    tools: List[Tool]

src/toolhouse/models/tools_models/anthropic.py

@@ -0,0 +1,36 @@
+from typing import Literal, List, Dict
+from pydantic import BaseModel
+
+
+ArgumentType = Literal["string", "number", "integer", "object", "array", "boolean"]
+
+
+class Property(BaseModel):
+    """Tool Property"""
+    type: ArgumentType
+    description: str
+
+
+class Paramenters(BaseModel):
+    """Parameters"""
+    type: Literal["object"]
+    properties: Dict[str, Property]
+
+
+class Function(BaseModel):
+    """InputSchema"""
+    name: str
+    description: str
+    parameters: Paramenters
+    required: List[str]
+
+
+class Tool(BaseModel):
+    """OpenAI Tools"""
+    type: Literal["function"]
+    function: Function
+
+
+class Tools(BaseModel):
+    """ToolHouse"""
+    tools: List[Tool]

src/toolhouse/models/tools_models/openai.py

@@ -0,0 +1,41 @@
+from typing import Literal, List
+from decimal import Decimal
+from pydantic import BaseModel, Field, HttpUrl
+
+
+ArgumentType = Literal["string", "number", "integer", "object", "array", "boolean"]
+ArgumentFrom = Literal["llm", "user", "metadata"]
+ToolType = Literal["local", "remote"]
+
+
+class Argument(BaseModel):
+    """Tool Arguments"""
+    name: str
+    type: ArgumentType
+    source: ArgumentFrom
+    label: str
+    description: str
+    required: bool
+
+
+class ToolHouseTool(BaseModel):
+    """ToolHouse Tools Configuration"""
+    id: str
+    publisher: str
+    tool_type: ToolType = "remote"
+    logo: str = Field(pattern=r'^data:image\/svg\+xml;base64,')
+    title: str
+    category: str
+    short_description: str
+    long_description: str
+    price_per_execution: Decimal = Field(gt=0)
+    star_rating: Decimal = Field(ge=0, le=5)
+    executions: int
+    url: HttpUrl
+    description_for_model: str
+    arguments: List[Argument]
+
+
+class Tools(BaseModel):
+    """ToolHouse"""
+    tools: List[ToolHouseTool]

src/toolhouse/models/tools_models/toolhouse.py

@@ -11,12 +11,13 @@
 from enum import Enum
 from typing import List, Union, Dict, Any, Optional
 
+from .exceptions import ToolhouseError
 from .net.environment import Environment
 from .services.tools import Tools
+from .services.local_tools import LocalTools
 from .models.Provider import Provider as ProviderModel
 from .models.RunToolsRequest import RunToolsRequest
 from .models.GetToolsRequest import GetToolsRequest
-from ._exceptions import ToolhouseError
 try:
     from .models.OpenAIStream import stream_to_chat_completion
 except ImportError:
@@ -71,7 +72,12 @@ def __init__(self, access_token: Optional[str] = None,
         self.metadata: Dict[str, Any] = {}
         self.set_base_url(environment.value if isinstance(
             environment, Environment) else environment)
+        self.local_tools: LocalTools = LocalTools()
 
+    def register_local_tool(self, local_tool):
+        """Register Local Tools"""
+        return self.local_tools.register_local_tool(local_tool)
+    
     def set_metadata(self, key: str, value) -> None:
         """
         Sets User Metadata
@@ -159,24 +165,15 @@ def run_tools(self, response, append: bool = True, stream=False) -> List:
 
             if tool_calls:
                 for tool in tool_calls:
-                    run_tool_request = RunToolsRequest(
-                        tool, self.provider, self.metadata)
-                    run_response = self.tools.run_tools(run_tool_request)
-                    messages.append(run_response.content)
-
-        elif self.provider in ("openai_assistants", ProviderModel.OPENAI_ASSISTANTS):
-            if 'submit_tool_outputs' not in response.required_action:
-                return []
-
-            submit_tool_outputs = response.required_action.submit_tool_outputs
-            tool_calls = getattr(submit_tool_outputs, 'tool_calls', None)
-            if tool_calls:
-                for tool in tool_calls:
-                    run_tool_request = RunToolsRequest(
-                        tool, self.provider, self.metadata)
-                    run_response = self.tools.run_tools(run_tool_request)
-                    messages.append(run_response.content)
-
+                    if tool.function.name in self.local_tools.get_registered_tools():
+                        result = self.local_tools.run_tools(tool)
+                        messages.append(result.model_dump())
+                    else:
+                        run_tool_request = RunToolsRequest(
+                            tool, self.provider, self.metadata)
+                        run_response = self.tools.run_tools(run_tool_request)
+                        messages.append(run_response.content)
+        
         elif self.provider in ("anthropic", ProviderModel.ANTHROPIC):
             if response.stop_reason != 'tool_use':
                 return []
@@ -186,11 +183,15 @@ def run_tools(self, response, append: bool = True, stream=False) -> List:
                 if tool.type == "tool_use":
                     if stream:
                         tool = tool.model_dump()
-                    run_tool_request = RunToolsRequest(
-                        tool, self.provider, self.metadata)
-                    run_response = self.tools.run_tools(run_tool_request)
-                    message['content'].append(run_response.content)
-
+                    if tool.name in self.local_tools.get_registered_tools():
+                        result = self.local_tools.run_tools(tool)
+                        message['content'].append(result.model_dump())
+                    else:
+                        run_tool_request = RunToolsRequest(
+                            tool, self.provider, self.metadata)
+                        run_response = self.tools.run_tools(run_tool_request)
+                        output = run_response.content
+                        message['content'].append(output)
             if message['content']:
                 if append:
                     messages.append({'role': 'assistant', 'content': response.content})

src/toolhouse/sdk.py

@@ -48,12 +48,14 @@ def __init__(self, access_token: str) -> None:
         """
         self._access_token = access_token
 
+    @classmethod
     def _pattern_matching(cls, value: str, pattern: str, variable_name: str):
         if re.match(r"{}".format(pattern), value):
             return value
         else:
             raise ValueError(f"Invalid value for {variable_name}: must match {pattern}")
 
+    @classmethod
     def _enum_matching(
         cls, value: Union[str, Enum], enum_values: List[str], variable_name: str
     ):