> ## 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

<ParamField body="type" type="str" required>
  Must be `"function"`.
</ParamField>

<ParamField body="definition" type="ToolFunctionDefinition" required>
  The function definition containing the schema. See [ToolFunctionDefinition](#toolfunctiondefinition).
</ParamField>

<ParamField body="request" type="FunctionRequestHttp | None" optional>
  Optional HTTP request configuration for executing the function via REST API. See [FunctionRequestHttp](#functionrequesthttp).
</ParamField>

### 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](/docs/reference/sdk/v2/python/types/ToolFunctionDefinition) 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

<ParamField body="var_schema" type="FunctionSchema" required>
  The function schema. Aliased as `schema` in JSON — use `var_schema` in Python to avoid collision with the Python reserved word.
</ParamField>

### 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](/docs/reference/sdk/v2/python/types/FunctionSchema) page for full documentation.

Function/tool schema definition for LLM function calling.

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

### Fields

<ParamField body="name" type="str" required>
  Function name. Must match `^[a-zA-Z0-9_]{1,64}$` (alphanumeric and underscores, max 64 chars).
</ParamField>

<ParamField body="description" type="str" required>
  Description of what the function does. Max 4096 characters.
</ParamField>

<ParamField body="parameters" type="dict[str, Any]" required>
  JSON Schema object describing the function parameters.
</ParamField>

<ParamField body="strict" type="bool | None" optional>
  Whether to enforce strict schema validation. When `True`, the LLM must conform exactly to the parameter schema.
</ParamField>

### 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

<ParamField body="type" type="str" required>
  Must be `"http"`.
</ParamField>

<ParamField body="method" type="str" required>
  HTTP method. One of: `"get"`, `"post"`.
</ParamField>

<ParamField body="url" type="str" required>
  The request URL. Supports `{{variable}}` template syntax.
</ParamField>

<ParamField body="headers" type="dict[str, str] | None" optional>
  Optional HTTP headers.
</ParamField>

<ParamField body="query" type="dict[str, str] | None" optional>
  Optional query parameters.
</ParamField>

<ParamField body="body" type="dict[str, Any] | None" optional>
  Optional request body.
</ParamField>

<ParamField body="proxy_url" type="str | None" optional>
  Optional proxy URL.
</ParamField>

<ParamField body="proxy_headers" type="dict[str, str] | None" optional>
  Optional proxy headers.
</ParamField>

<ParamField body="retry" type="FunctionRequestRetry | None" optional>
  Optional retry configuration. See [FunctionRequestRetry](#functionrequestretry).
</ParamField>

### 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

<ParamField body="max_attempts" type="int" required>
  Maximum number of retry attempts. Minimum: 1.
</ParamField>

<ParamField body="initial_delay" type="int" required>
  Initial delay in milliseconds. Minimum: 1.
</ParamField>

<ParamField body="exponential_factor" type="int" required>
  Multiplier for each subsequent retry. Minimum: 1.
</ParamField>

### 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}")
```