Tool Decorator

Calling a decorated function will create a Tool Log with the following fields:

• inputs: The function arguments.
• output: The function return value.
• error: The error message if the function call fails.

@hl_client.tool(
    # Required: path on Humanloop workspace for the Tool
    path: str,
    # Optional: additional metadata for the Tool
    attributes: Optional[dict[str, Any]] = None,
    # Optional: values needed to setup the Tool
    setup_values: Optional[dict[str, Any]] = None
)
def function(*args, **kwargs): ...

The decorated function will have the same signature as the original function and will have a json_schema attribute containing the inferred JSON Schema.

@hl_client.tool(path="MyFeature/Calculator")
def calculator(a: int, b: Optional[int] = None) -> int:
    """Add two numbers together."""
    return a + (b or 0)

Decorating a function will set a json_schema attribute that can be used for function calling.

# Use with prompts.call
response = hl_client.prompts.call(
    path="MyFeature/Assistant",
    messages=[{"role": "user", "content": "What is 5 + 3?"}],
    tools=[calculator.json_schema]
)
# Or with OpenAI directly!
response = openai.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "What is 5 + 3?"}],
    tools=[{
        "type": "function",
        "function": calculator.json_schema
    }]
)

In Python, the decorator automatically infers a JSON Schema from the source code, argument signature, and docstrings:

• Function name becomes the tool name
• Function docstring becomes the tool description
• Parameter type hints are converted to JSON Schema types
• Optional parameters (using Optional[T] or T | None) are marked as not required
• Return type is not included in the schema

Supported type hints:

• Function errors are caught and logged in the Log’s error field.
• The decorated function returns None when an error occurs.
• HumanloopRuntimeError is not caught and will be re-raised, as it indicates incorrect SDK or decorator usage.

1. Use clear and descriptive docstrings in Python to provide good tool descriptions
2. Ensure all function parameters have appropriate type hints in Python
3. Make return values JSON-serializable
4. Use the json_schema attribute when passing the tool to prompts.call()