> ## Documentation Index
> Fetch the complete documentation index at: https://www.adaline.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# ToolFunction

# ToolFunction

Types for defining tools, functions, and their execution configurations.

## Overview

Tool types define how LLMs can call external functions, including schemas, parameters, HTTP configurations, and retry logic.

***

## ToolFunction

Tool function definition with schema and optional HTTP request configuration.

```python theme={null}
from adaline_api.models.tool_function import ToolFunction
```

### Fields

**type** `str` *required*

Must be `"function"`.

**definition** `ToolFunctionDefinition` *required*

The function definition containing the schema. See [ToolFunctionDefinition](#toolfunctiondefinition).

**request** `FunctionRequestHttp | None`

Optional HTTP request configuration for executing the function via REST API. See [FunctionRequestHttp](#functionrequesthttp).

### Example

```python theme={null}
from adaline_api.models.tool_function import ToolFunction
from adaline_api.models.tool_function_definition import ToolFunctionDefinition
from adaline_api.models.function_schema import FunctionSchema

tool = ToolFunction(
    type="function",
    definition=ToolFunctionDefinition(
        var_schema=FunctionSchema(
            name="get_weather",
            description="Get current weather",
            parameters={
                "type": "object",
                "properties": {
                    "city": {"type": "string"}
                },
                "required": ["city"]
            }
        )
    )
)
```

***

## ToolFunctionDefinition

See the dedicated [ToolFunctionDefinition](https://www.adaline.ai/docs/reference/sdk/v2/python/types/ToolFunctionDefinition.md) page for full documentation.

Wrapper for a function schema within a tool definition.

```python theme={null}
from adaline_api.models.tool_function_definition import ToolFunctionDefinition
```

### Fields

**var\_schema** `FunctionSchema` *required*

The function schema. Aliased as `schema` in JSON — use `var_schema` in Python to avoid collision with the Python reserved word.

### Example

```python theme={null}
from adaline_api.models.tool_function_definition import ToolFunctionDefinition
from adaline_api.models.function_schema import FunctionSchema

definition = ToolFunctionDefinition(
    var_schema=FunctionSchema(
        name="search_database",
        description="Search internal database",
        parameters={
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"},
                "limit": {"type": "number", "default": 10}
            },
            "required": ["query"]
        }
    )
)
```

***

## FunctionSchema

See the dedicated [FunctionSchema](https://www.adaline.ai/docs/reference/sdk/v2/python/types/FunctionSchema.md) page for full documentation.

Function/tool schema definition for LLM function calling.

```python theme={null}
from adaline_api.models.function_schema import FunctionSchema
```

### Fields

**name** `str` *required*

Function name. Must match `^[a-zA-Z0-9_]{1,64}$` (alphanumeric and underscores, max 64 chars).

**description** `str` *required*

Description of what the function does. Max 4096 characters.

**parameters** `dict[str, Any]` *required*

JSON Schema object describing the function parameters.

**strict** `bool | None`

Whether to enforce strict schema validation. When `True`, the LLM must conform exactly to the parameter schema.

### Example

```python theme={null}
from adaline_api.models.function_schema import FunctionSchema

weather_function = FunctionSchema(
    name="get_weather",
    description="Get current weather for a city",
    parameters={
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "City name"
            },
            "units": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "default": "celsius",
                "description": "Temperature units"
            }
        },
        "required": ["city"]
    },
    strict=True
)
```

**JSON**:

```json theme={null}
{
  "name": "get_weather",
  "description": "Get weather for a city",
  "parameters": {
    "type": "object",
    "properties": {
      "city": { "type": "string" }
    },
    "required": ["city"]
  }
}
```

***

## FunctionRequestHttp

HTTP request configuration for executing functions via REST API.

```python theme={null}
from adaline_api.models.function_request_http import FunctionRequestHttp
```

### Fields

**type** `str` *required*

Must be `"http"`.

**method** `str` *required*

HTTP method. One of: `"get"`, `"post"`.

**url** `str` *required*

The request URL. Supports `{{variable}}` template syntax.

**headers** `dict[str, str] | None`

Optional HTTP headers.

**query** `dict[str, str] | None`

Optional query parameters.

**body** `dict[str, Any] | None`

Optional request body.

**proxy\_url** `str | None`

Optional proxy URL.

**proxy\_headers** `dict[str, str] | None`

Optional proxy headers.

**retry** `FunctionRequestRetry | None`

Optional retry configuration. See [FunctionRequestRetry](#functionrequestretry).

### Example

```python theme={null}
from adaline_api.models.function_request_http import FunctionRequestHttp
from adaline_api.models.function_request_retry import FunctionRequestRetry

http_request = FunctionRequestHttp(
    type="http",
    method="post",
    url="https://api.weather.com/v1/current",
    headers={
        "Authorization": "Bearer {{API_KEY}}",
        "Content-Type": "application/json"
    },
    query={"units": "metric"},
    body={"location": "{{city}}"},
    retry=FunctionRequestRetry(
        max_attempts=3,
        initial_delay=1000,
        exponential_factor=2
    )
)
```

***

## FunctionRequestRetry

Retry configuration with exponential backoff.

```python theme={null}
from adaline_api.models.function_request_retry import FunctionRequestRetry
```

### Fields

**max\_attempts** `int` *required*

Maximum number of retry attempts. Minimum: 1.

**initial\_delay** `int` *required*

Initial delay in milliseconds. Minimum: 1.

**exponential\_factor** `int` *required*

Multiplier for each subsequent retry. Minimum: 1.

### Example

```python theme={null}
from adaline_api.models.function_request_retry import FunctionRequestRetry

retry = FunctionRequestRetry(
    max_attempts=3,
    initial_delay=1000,       # Start with 1 second
    exponential_factor=2      # Double each retry: 1s, 2s, 4s
)
```

***

## Complete Example

```python theme={null}
from adaline.main import Adaline
from adaline_api.models.tool_function import ToolFunction
from adaline_api.models.tool_function_definition import ToolFunctionDefinition
from adaline_api.models.function_schema import FunctionSchema
from adaline_api.models.function_request_http import FunctionRequestHttp
from adaline_api.models.function_request_retry import FunctionRequestRetry

# Define retry configuration
retry = FunctionRequestRetry(
    max_attempts=3,
    initial_delay=1000,
    exponential_factor=2
)

# Define HTTP request
request = FunctionRequestHttp(
    type="http",
    method="post",
    url="https://api.weather.com/current",
    headers={
        "Authorization": "Bearer sk_abc123",
        "Content-Type": "application/json"
    },
    body={"city": "{{city}}", "units": "{{units}}"},
    retry=retry
)

# Define function schema
schema = FunctionSchema(
    name="get_weather",
    description="Get current weather for a city",
    parameters={
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "City name"
            },
            "units": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "default": "celsius"
            }
        },
        "required": ["city"]
    }
)

# Complete tool definition
tool = ToolFunction(
    type="function",
    definition=ToolFunctionDefinition(var_schema=schema),
    request=request
)
```

### Using Tools from a Deployment

```python theme={null}
adaline = Adaline()

deployment = await adaline.get_latest_deployment(
    prompt_id="prompt_with_tools",
    deployment_environment_id="environment_abc123"
)

print(f"Tools available: {len(deployment.prompt.tools)}")
for t in deployment.prompt.tools:
    fn = t.definition.var_schema
    print(f"  - {fn.name}: {fn.description}")
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.