Decorators

Two decorators in bridle.

agent

bridle.agent(
    *,
    input: type | None = None,
    output: type | None = None,
    model: str | None = None,
    system: str | None = None,
    token_budget: int | None = None,
    name: str | None = None,
)

Mark a function as an agent. Each call to the decorated function returns a Call of kind "agent". The body runs when the call is resolved.

Returns: a decorator that takes a callable and returns a wrapper. The wrapper, when called, returns a Call.

Behavior:

• If input is a Pydantic model and the first arg isn't an instance, Bridle coerces it via model_validate.
• If output is a Pydantic model and the body returns a non-instance, Bridle coerces it via model_validate.
• model and token_budget are pushed into context at the agent boundary; nested agents inherit and may override.
• The body's return value is resolve()'d before being returned, so returning an inner Call works transparently.

Raises during resolution:

• pydantic.ValidationError — input or output failed.
• ConfigurationError — no callable in the call's options (only happens if you construct the Call by hand).
• Anything the body raises.

tool

bridle.tool(
    fn: Callable | None = None,
    /,
    *,
    name: str | None = None,
    description: str | None = None,
    raise_on_error: bool = False,
) -> Tool | Callable[[Callable], Tool]

Wrap a typed Python function as a Tool. Use bare or with arguments:

@tool
def search(query: str) -> list[str]: ...

@tool(name="lookup", raise_on_error=True)
def lookup(record_id: str) -> Record: ...

Behavior:

• Type hints become the parameter schema via pydantic.create_model.
• *args and **kwargs are skipped.
• A parameter with a default value becomes optional in the schema.

Returns: a Tool (when used bare) or a decorator producing a Tool.

Tool class

@dataclass(frozen=True)
class Tool:
    name: str
    description: str
    parameters_schema: dict[str, Any]
    fn: Callable[..., Any]
    raise_on_error: bool = False
    metadata: dict[str, Any] = ...

A Tool is callable — Tool.__call__ forwards to fn. Useful for unit-testing tools as plain functions:

@tool
def add(x: int, y: int) -> int:
    """Add two numbers."""
    return x + y

assert add(2, 3) == 5

Related