Tool System

from agentor import function_tool

@function_tool
def get_weather(city: str) -> str:
    """Returns the weather in the given city."""
    return f"The weather in {city} is sunny"

agent = Agentor(
    name="Weather Agent",
    tools=[get_weather]
)

{
  "name": "get_weather",
  "description": "Returns the weather in the given city.",
  "parameters": {
    "type": "object",
    "properties": {
      "city": {"type": "string"}
    },
    "required": ["city"]
  }
}

from agentor.tools.registry import register_global_tool
from agents import RunContextWrapper
from agentor.tools.registry import CelestoConfig

@register_global_tool
def get_weather(wrapper: RunContextWrapper[CelestoConfig], city: str) -> str:
    """Returns the weather in the given city."""
    api_key = wrapper.context.weather_api_key
    # Fetch weather using API key
    return f"Weather in {city}"

agent = Agentor(
    name="Agent",
    tools=["get_weather"]  # Reference by string name
)

from agentor.tools.registry import ToolRegistry

tools = ToolRegistry.list()
print(tools)  # ('get_weather', 'current_datetime')

from agentor.tools.base import BaseTool, capability

class WeatherTool(BaseTool):
    name = "weather"
    description = "Weather information tool"
    
    def __init__(self, api_key: str):
        super().__init__(api_key=api_key)
    
    @capability
    def get_current_weather(self, city: str) -> str:
        """Get current weather for a city"""
        return f"Weather in {city}: Sunny, 72°F"
    
    @capability
    def get_forecast(self, city: str, days: int = 5) -> str:
        """Get weather forecast for multiple days"""
        return f"{days}-day forecast for {city}"

# Use with agent
agent = Agentor(
    name="Weather Agent",
    tools=[WeatherTool(api_key="YOUR_KEY")]
)

def capability(func: Callable):
    """Decorator to mark a method as a tool capability."""
    func._is_capability = True
    return func

from agentor.tools.base import BaseTool

def weather_tool(city: str):
    """This function returns the weather of the city."""
    return f"Weather in {city} is warm and sunny."

tool = BaseTool.from_function(weather_tool)
result = tool.run("London")
print(result)  # Weather in London is warm and sunny.

class WeatherTool(BaseTool):
    name = "weather-service"
    
    @capability
    def get_weather(self, location: str) -> str:
        return f"Weather in {location}"

tool = WeatherTool()
tool.serve(port=8000)

from agentor.tools import GetWeatherTool

weather = GetWeatherTool(api_key="YOUR_KEY")
result = weather.get_current_weather("London")

from agentor.tools.github import GitHubTool

gh = GitHubTool(api_key="YOUR_TOKEN")
repos = gh.list_repositories("celestoai")

from agentor.tools.gmail import GmailTool

gmail = GmailTool(credentials_path="credentials.json")
emails = gmail.search_messages("from:user@example.com")

from agentor.tools.shell import ShellTool

shell = ShellTool()
result = shell.run_command("ls -la")

tool = WeatherTool()
schema = tool.json_schema()
print(schema)

[
  {
    "type": "function",
    "name": "weather",
    "description": "Weather information tool",
    "parameters": {
      "type": "object",
      "properties": {
        "city": {"type": "string"},
        "days": {"type": "integer"}
      },
      "required": ["city"]
    }
  }
]

from agentor import ToolSearch

tool_search = ToolSearch()
agent = Agentor(
    name="Agent",
    tools=tool_search.search("weather operations")
)

@function_tool
def risky_operation(param: str) -> str:
    """Performs a risky operation"""
    try:
        # Perform operation
        return "Success"
    except Exception as e:
        return f"Failed to execute: {e}"

from dataclasses import dataclass
import os

@dataclass
class CelestoConfig:
    weather_api_key: str | None = os.environ.get("WEATHER_API_KEY")
    github_token: str | None = os.environ.get("GITHUB_TOKEN")

@register_global_tool
def github_operation(wrapper: RunContextWrapper[CelestoConfig], repo: str) -> str:
    token = wrapper.context.github_token
    # Use token for API calls
    return f"Processed {repo}"

tools = weather_tool.to_openai_function()
# Returns List[FunctionTool] compatible with agents library