Crowe Basetool

Crowe BaseTool

Overview Crowe BaseTool is a unified tool execution and schema management framework designed for AI-powered workflows. It streamlines function calling, schema conversion, and tool execution across providers like OpenAI and Anthropic, with built-in validation, caching, and error handling.

Key Capabilities

Function → AI Schema Instantly convert Python functions to standardized function-calling schemas.
Multi-Provider Schema Support Validate and convert between OpenAI, Anthropic, and other AI provider formats.
Execution Engine Run tools sequentially or in parallel with robust error handling and automatic retries.
Pydantic Integration Manage, validate, and serialize Pydantic models with ease.
Auto Execution Detect and execute tools directly from API responses.
Performance-Ready Caching system for repeated calls to boost speed and reduce cost.

Initialization Parameters

Parameter

Type

Default

Description

verbose

bool

None

Enable detailed logs.

base_models

List[BaseModel]

None

Pydantic models to manage.

autocheck

bool

None

Enable schema and type validation.

auto_execute_tool

bool

None

Auto-run tools from responses.

tools

List[Callable]

None

Functions to register as tools.

tool_system_prompt

str

None

Custom system prompt for tools.

function_map

Dict[str, Callable]

None

Map of function names to callables.

list_of_dicts

List[Dict]

None

Pre-defined schema dictionaries.

Core Methods

Schema Conversion
- func_to_dict() → Convert Python functions into AI tool schemas.
- base_model_to_dict() / multi_base_models_to_dict() → Pydantic → AI schema.
- convert_schema_between_providers() → Cross-provider schema translation.
Execution
- execute_tool() → Run tool with input validation.
- dynamic_run() → Auto-detect input type and execute.
- execute_tool_from_text() → Run tools from JSON strings.
Validation & Inspection
- check_func_if_have_docs() → Ensure functions are documented.
- check_func_if_have_type_hints() → Verify type hints.
- validate_function_schema() → Confirm schema compliance.
Automation
- execute_function_calls_from_api_response() → Parse and run API function calls.
- detect_api_response_format() → Identify API provider response type.

BaseTool — Method Highlights

func_to_dict

Convert any Python function into an OpenAI function calling schema. Useful for exposing local functions directly to an AI model.

from swarms.tools.base_tool import BaseTool

def add_numbers(a: int, b: int) -> int:
    """Add two numbers together."""
    return a + b

tool = BaseTool(verbose=True)
schema = tool.func_to_dict(add_numbers)
print(schema)
# {'type': 'function', 'function': {'name': 'add_numbers', 'description': 'Add two numbers together.', 'parameters': {...}}}

load_params_from_func_for_pybasemodel

Automatically generate Pydantic model parameters from a function for type-safe input validation.

from swarms.tools.base_tool import BaseTool

def calculate_area(length: float, width: float) -> float:
    """Calculate area of a rectangle."""
    return length * width

tool = BaseTool()
processed_func = tool.load_params_from_func_for_pybasemodel(calculate_area)

result = processed_func(5.0, 3.0)
print(result)  # 15.0

base_model_to_dict

Convert a Pydantic BaseModel to an AI-callable schema.

from pydantic import BaseModel
from swarms.tools.base_tool import BaseTool

class UserInfo(BaseModel):
    name: str
    age: int
    email: str

tool = BaseTool()
schema = tool.base_model_to_dict(UserInfo)
print(schema)

multi_base_models_to_dict

Merge multiple Pydantic models into a single schema.

from pydantic import BaseModel
from swarms.tools.base_tool import BaseTool

class User(BaseModel):
    name: str
    age: int

class Product(BaseModel):
    name: str
    price: float

tool = BaseTool()
schemas = tool.multi_base_models_to_dict([User, Product])
print(schemas)

dict_to_openai_schema_str

Convert a schema dictionary into a string for OpenAI function calling.

from swarms.tools.base_tool import BaseTool

my_dict = {
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get weather information",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}}
    }
}

tool = BaseTool()
schema_str = tool.dict_to_openai_schema_str(my_dict)
print(schema_str)

multi_dict_to_openai_schema_str

Combine multiple schema dictionaries into one string.

from swarms.tools.base_tool import BaseTool

dict1 = {"type": "function", "function": {"name": "func1", "description": "Function 1"}}
dict2 = {"type": "function", "function": {"name": "func2", "description": "Function 2"}}

tool = BaseTool()
schema_str = tool.multi_dict_to_openai_schema_str([dict1, dict2])
print(schema_str)

execute_tool

Execute a tool based on a JSON response string (name + parameters).

from swarms.tools.base_tool import BaseTool

def greet(name: str) -> str:
    """Greet a person by name."""
    return f"Hello, {name}!"

tool = BaseTool(tools=[greet])

response = '{"name": "greet", "parameters": {"name": "Alice"}}'
result = tool.execute_tool(response)
print(result)  # "Hello, Alice!"

detect_tool_input_type

Detect the input category to choose the right processing path: "Pydantic" | "Dictionary" | "Function" | "Unknown".

from swarms.tools.base_tool import BaseTool
from pydantic import BaseModel

class MyModel(BaseModel):
    value: int

def my_function():
    return "ok"

tool = BaseTool()

print(tool.detect_tool_input_type(MyModel))        # "Pydantic"
print(tool.detect_tool_input_type(my_function))    # "Function"
print(tool.detect_tool_input_type({"k": "v"}))     # "Dictionary"
print(tool.detect_tool_input_type(42))             # "Unknown"

dynamic_run

Auto-detect the input type (Pydantic class, dict schema, or function) and do the right thing (e.g., return schema string or execute).

from swarms.tools.base_tool import BaseTool

def multiply(x: int, y: int) -> int:
    """Multiply two numbers."""
    return x * y

tool = BaseTool(auto_execute_tool=False)

schema_or_result = tool.dynamic_run(multiply)
print(type(schema_or_result), schema_or_result)  # typically a schema string

execute_tool_by_name

Find a registered tool by name and execute it with JSON parameters.

from swarms.tools.base_tool import BaseTool

def calculate_sum(a: int, b: int) -> int:
    """Calculate sum of two numbers."""
    return a + b

tool = BaseTool(function_map={"calculate_sum": calculate_sum})
result = tool.execute_tool_by_name("calculate_sum", '{"a": 5, "b": 3}')
print(result)  # 8

execute_tool_from_text

Parse a JSON tool-call string ({"name": "...","parameters": {...}}) and execute it.

from swarms.tools.base_tool import BaseTool

def divide(x: float, y: float) -> float:
    """Divide x by y."""
    return x / y

tool = BaseTool(function_map={"divide": divide})
text = '{"name": "divide", "parameters": {"x": 10, "y": 2}}'
print(tool.execute_tool_from_text(text))  # 5.0

check_str_for_functions_valid

Validate if a string is JSON and the function name exists in the function map.

from swarms.tools.base_tool import BaseTool

def test_func():
    return "ok"

tool = BaseTool(function_map={"test_func": test_func})

valid_output = '{"type":"function","function":{"name":"test_func"}}'
print(tool.check_str_for_functions_valid(valid_output))  # True

invalid_output = '{"type":"function","function":{"name":"missing"}}'
print(tool.check_str_for_functions_valid(invalid_output))  # False

convert_funcs_into_tools

Convert all functions in tools into internal OpenAI-style tool format, populating function_map.

from swarms.tools.base_tool import BaseTool

def func1(x: int) -> int:
    """Function 1."""
    return x * 2

def func2(y: str) -> str:
    """Function 2."""
    return y.upper()

tool = BaseTool(tools=[func1, func2])
tool.convert_funcs_into_tools()
print(sorted(tool.function_map.keys()))  # ['func1', 'func2']

convert_tool_into_openai_schema

Export all registered tools as a combined OpenAI function-calling schema.

from swarms.tools.base_tool import BaseTool

def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

def subtract(a: int, b: int) -> int:
    """Subtract b from a."""
    return a - b

tool = BaseTool(tools=[add, subtract])
schema = tool.convert_tool_into_openai_schema()
print(schema)  # dict with 'type': 'function' entries for add/subtract

check_func_if_have_docs

Ensure a function has a docstring. (Implementations may return True or raise a specific error if missing.)

from swarms.tools.base_tool import BaseTool

def documented_func():
    """This function has documentation."""
    return "ok"

def undocumented_func():
    return "nope"

tool = BaseTool()
print(tool.check_func_if_have_docs(documented_func))  # True

# Depending on implementation, the next line may raise ToolDocumentationError:
# tool.check_func_if_have_docs(undocumented_func)

check_func_if_have_type_hints

Ensure a function has proper type hints. (Implementations may return True or raise a specific error if missing.)

from swarms.tools.base_tool import BaseTool

def typed_func(x: int) -> str:
    """A typed function."""
    return str(x)

def untyped_func(x):
    """An untyped function."""
    return str(x)

tool = BaseTool()
print(tool.check_func_if_have_type_hints(typed_func))  # True

# Depending on implementation, may raise ToolTypeHintError:
# tool.check_func_if_have_type_hints(untyped_func)

find_function_name

Find a function by name in the registered tool set.

from swarms.tools.base_tool import BaseTool

def my_function():
    """My function."""
    return "hello"

tool = BaseTool(tools=[my_function])
found = tool.find_function_name("my_function")
print(found is my_function)  # True

function_to_dict

Convert a function into a dictionary representation (name, docstring, params).

from swarms.tools.base_tool import BaseTool

def example_func(param: str) -> str:
    """Example function."""
    return param

tool = BaseTool()
func_dict = tool.function_to_dict(example_func)
print(func_dict)  # {'name': 'example_func', 'description': 'Example function.', 'parameters': {...}}

multiple_functions_to_dict

Convert a list of functions into a list of dict representations.

from swarms.tools.base_tool import BaseTool

def func1(x: int) -> int:
    """Function 1."""
    return x

def func2(y: str) -> str:
    """Function 2."""
    return y

tool = BaseTool()
func_dicts = tool.multiple_functions_to_dict([func1, func2])
print(func_dicts)  # [{'name': 'func1', ...}, {'name': 'func2', ...}]

execute_function_with_dict

Execute a function using a dictionary of parameters. Useful when arguments are produced by a model or parsed from JSON.

from swarms.tools.base_tool import BaseTool

def power(base: int, exponent: int) -> int:
    """Calculate base to the power of exponent."""
    return base ** exponent

tool = BaseTool(tools=[power])

# Provide params as a dict; specify the function by name
result = tool.execute_function_with_dict({"base": 2, "exponent": 3}, "power")
print(result)  # 8

execute_multiple_functions_with_dict

Execute multiple functions from a list of parameter dictionaries (optionally specify names if auto-detection isn’t used).

from swarms.tools.base_tool import BaseTool

def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

tool = BaseTool(tools=[add, multiply])

results = tool.execute_multiple_functions_with_dict(
    [{"a": 1, "b": 2}, {"a": 3, "b": 4}],
    ["add", "multiply"]
)
print(results)  # [3, 12]

validate_function_schema

Validate a function schema for a target provider ("openai", "anthropic", "generic", or "auto").

from swarms.tools.base_tool import BaseTool

openai_schema = {
    "type": "function",
    "function": {
        "name": "add_numbers",
        "description": "Add two numbers",
        "parameters": {
            "type": "object",
            "properties": {
                "a": {"type": "integer"},
                "b": {"type": "integer"}
            },
            "required": ["a", "b"]
        }
    }
}

tool = BaseTool()
is_valid = tool.validate_function_schema(openai_schema, provider="openai")
print(is_valid)  # True (if valid)

get_schema_provider_format

Detect the provider format of a given schema dict.

from swarms.tools.base_tool import BaseTool

openai_schema = {
    "type": "function",
    "function": {"name": "test", "description": "Test function"}
}

tool = BaseTool()
provider = tool.get_schema_provider_format(openai_schema)
print(provider)  # "openai"

convert_schema_between_providers

Convert a function schema between providers (e.g., OpenAI → Anthropic).

from swarms.tools.base_tool import BaseTool

openai_schema = {
    "type": "function",
    "function": {
        "name": "test_func",
        "description": "Test function",
        "parameters": {"type": "object", "properties": {}}
    }
}

tool = BaseTool()
anthropic_schema = tool.convert_schema_between_providers(openai_schema, "anthropic")
print(anthropic_schema)
# e.g. {"name": "test_func", "description": "Test function", "input_schema": {...}}

execute_function_calls_from_api_response

Auto-detect and execute function calls embedded in OpenAI/Anthropic responses. Can run sequentially or in parallel.

from swarms.tools.base_tool import BaseTool

def get_weather(city: str) -> str:
    """Get weather for a city."""
    return f"Weather in {city}: Sunny, 25°C"

# Simulated OpenAI-style response with a tool call
openai_response = {
    "choices": [{
        "message": {
            "tool_calls": [{
                "type": "function",
                "function": {
                    "name": "get_weather",
                    "arguments": '{"city": "New York"}'
                },
                "id": "call_123"
            }]
        }
    }]
}

tool = BaseTool(tools=[get_weather])

# Execute discovered tool calls
results = tool.execute_function_calls_from_api_response(
    api_response=openai_response,
    sequential=True,       # or False for parallel
    max_workers=4,
    return_as_string=True  # pretty formatted strings
)

print(results)
# ["Function 'get_weather' result:\nWeather in New York: Sunny, 25°C"]

detect_api_response_format

Detect whether a response looks like OpenAI, Anthropic, generic, or unknown.

from swarms.tools.base_tool import BaseTool

openai_response = {"choices": [{"message": {"tool_calls": []}}]}
anthropic_response = {"content": [{"type": "tool_use", "name": "test", "input": {}}]}

tool = BaseTool()
print(tool.detect_api_response_format(openai_response))   # "openai"
print(tool.detect_api_response_format(anthropic_response))# "anthropic"

Exception Classes

Custom exceptions for precise error handling:

BaseToolError — Base class for all BaseTool-related errors
ToolValidationError — Schema/tool validation failed
ToolExecutionError — Tool execution failed
ToolNotFoundError — Requested tool not found
FunctionSchemaError — Failed during schema conversion
ToolDocumentationError — Missing/invalid function docstring
ToolTypeHintError — Missing/invalid type hints

Example handling:

from swarms.tools.base_tool import BaseTool, ToolNotFoundError

tool = BaseTool(function_map={})
try:
    tool.execute_tool_by_name("no_such_function", "{}")
except ToolNotFoundError as e:
    print(f"Not found: {e}")

Usage Tips

Provide docstrings and type hints for every function to enable clean schemas and validation.
Use verbose=True during development to surface detailed logs.
Pre-fill function_map for direct name-based execution.
Validate schemas before sending them to different providers.
Use parallel execution for high-throughput batches.
Catch specific BaseTool exceptions for robust error handling.

PreviousCrowe Orchestrator

Last updated 9 days ago