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.

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.

request · FunctionRequestHttp | None

Optional HTTP request configuration for executing the function via REST API. See FunctionRequestHttp.

Example

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 page for full documentation.

Wrapper for a function schema within a tool definition.

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

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 page for full documentation.

Function/tool schema definition for LLM function calling.

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

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:

{
  "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.

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.

Example

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.

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

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

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

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