Tokitai

https://docs.rs/tokitai/latest/
Admin
Tokitai is a zero-runtime-dependency procedural macro library that transforms Rust methods into...
Tokens:112,981
Snippets:1,522
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Create ToolConfig Parameter Example

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=

Use this function to create a parameter configuration that specifies an example value for a parameter. This is useful for documentation or default behavior.

```rust
use tokitai_core::ToolConfig;
use serde_json::json;

let c = ToolConfig::param_example("id", json!("user-42"));
assert!(matches!(c, ToolConfig::ParamExample { .. }));
```

--------------------------------

### Example Search Queries

Source: https://docs.rs/tokitai/latest/tokitai/attr.tool_desc.html?search=

These are example search queries demonstrating different patterns. They cover searching for standard library types, type transformations, and generic type mappings.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example Usage of ToolConfigRegistry

Source: https://docs.rs/tokitai/latest/tokitai/static.GLOBAL_CONFIG_REGISTRY.html

Demonstrates how to create a default registry, configure a tool with a description, and retrieve its configurations. This example shows a typical use case for managing tool configurations.

```rust
use tokitai_core::{ToolConfig, ToolConfigRegistry};

let registry = ToolConfigRegistry::default();
registry.configure("get_user", &[
    ToolConfig::Desc("Description".to_string()),
]);

let configs = registry.get("get_user");
assert_eq!(configs.len(), 1);
```

--------------------------------

### param_example

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a parameter example configuration for a given name and a JSON Value.

```APIDOC
## pub fn param_example<N>(name: N, example: Value) -> ToolConfig

### Description
Create a parameter example configuration.

### Parameters
#### Path Parameters
- **name** (N): The name of the parameter.
- **example** (Value): The example value for the parameter.

### Returns
- ToolConfig: A ToolConfig object with the parameter example configuration.
```

--------------------------------

### param_example

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=std%3A%3Avec

Creates a ToolConfig with a specified parameter example. This is useful for providing a sample value for a parameter.

```APIDOC
## pub fn param_example<N>(name: N, example: Value) -> ToolConfig

### Description
Create a parameter example configuration.

### Parameters
#### Path Parameters
- **name** (N): The name of the parameter.
- **example** (Value): The example value for the parameter.

### Returns
- ToolConfig: A ToolConfig enum variant representing a parameter example.
```

--------------------------------

### Example of Calling a Tool by Name

Source: https://docs.rs/tokitai/latest/tokitai/trait.ToolCaller.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates invoking a tool by its name and arguments. This snippet is a commented-out example showing the expected usage after the #[tool] macro has been applied to a struct like Calculator.

```rust
use tokitai_core::ToolCaller;
use serde_json::json;

// After `#[tool]` has been applied to Calculator:
// let result = calc.call_tool("add", &json!({"a": 1, "b": 2})).unwrap();
// assert_eq!(result, json!(3));
```

--------------------------------

### Example Searches with tool_max_items

Source: https://docs.rs/tokitai/latest/tokitai/attr.tool_max_items.html?search=

These examples demonstrate how the tool_max_items attribute can be used in various search scenarios, including searching standard library vectors, type conversions, and generic option transformations.

```Rust
std::vec

```

```Rust
u32 -> bool

```

```Rust
Option<T>, (T -> U) -> Option<U>

```

--------------------------------

### Example usage of ToolConfigRegistry

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolConfigRegistry.html?search=u32+-%3E+bool

Demonstrates the basic workflow of creating a registry, configuring a tool with description and parameters, and querying its configurations.

```rust
use tokitai_core::{ToolConfig, ToolConfigRegistry};

let registry = ToolConfigRegistry::default();

// Configure a tool
registry.configure("get_user", &[
    ToolConfig::Desc("Get user information".to_string()),
    ToolConfig::param_desc("id", "User ID"),
]);

// Query configurations
let configs = registry.get("get_user");
assert!(!configs.is_empty());
```

--------------------------------

### ParamType Conversion Examples

Source: https://docs.rs/tokitai/latest/tokitai/enum.ParamType.html?search=

Demonstrates converting Rust type names to ParamType and ParamType variants to their string representations.

```rust
use tokitai_core::ParamType;

assert_eq!(ParamType::from_rust_type("String"), Some(ParamType::String));
assert_eq!(ParamType::from_rust_type("i32"), Some(ParamType::Integer));
assert_eq!(ParamType::Integer.as_str(), "integer");
```

--------------------------------

### Example Usage of ToolCaller

Source: https://docs.rs/tokitai/latest/tokitai/trait.ToolCaller.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the call_tool method to invoke a tool named 'add' with specific arguments and assert the expected result. This example assumes a Calculator struct has been annotated with #[tool].

```rust
use tokitai_core::{ToolProvider, ToolCaller};
use serde_json::json;

let calc = Calculator;
let result = calc.call_tool("add", &json!({"a": 10, "b": 20})).unwrap();
assert_eq!(result, json!(30));
```

--------------------------------

### Create a new empty ToolConfigRegistry

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolConfigRegistry.html?search=u32+-%3E+bool

Initializes an empty registry. Use this when you need a fresh instance to start registering configurations.

```rust
use tokitai_core::ToolConfigRegistry;

let registry = ToolConfigRegistry::new();
assert!(!registry.has_config("any_tool"));
```

--------------------------------

### param_tool Macro Usage

Source: https://docs.rs/tokitai/latest/tokitai/attr.param_tool.html

Example demonstrating how to use the #[param_tool] macro with various options like validation, transformation, default values, and descriptions.

```rust
#[tool]
impl MyTools {
    pub fn create_user(
        &self,
        #[param_tool(validate = "!value.is_empty()", desc = "Name cannot be empty")]
        name: String,
        #[param_tool(transform = "value.to_lowercase() ")]
        email: String,
        #[param_tool(default = 10)]
        count: i32,
    ) -> Result<String, Error> {
        // ...
    }
}
```

--------------------------------

### ParamType as_str Method Examples

Source: https://docs.rs/tokitai/latest/tokitai/enum.ParamType.html?search=u32+-%3E+bool

Demonstrates converting ParamType variants to their JSON Schema string keywords.

```rust
use tokitai_core::ParamType;

assert_eq!(ParamType::String.as_str(), "string");
assert_eq!(ParamType::Integer.as_str(), "integer");
```

--------------------------------

### ToolConfigRegistry::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolConfigRegistry.html?search=u32+-%3E+bool

Creates a new, empty registry for tool configurations. This is the starting point for managing tool settings.

```APIDOC
## ToolConfigRegistry::new

### Description
Creates a new empty registry.

### Method
`new()`

### Returns
A new `ToolConfigRegistry` instance.

### Example
```rust
use tokitai_core::ToolConfigRegistry;

let registry = ToolConfigRegistry::new();
assert!(!registry.has_config("any_tool"));
```
```

--------------------------------

### Example Usage of ToolProvider

Source: https://docs.rs/tokitai/latest/tokitai/trait.ToolProvider.html

Demonstrates how to use the ToolProvider trait methods after the `#[tool]` macro has been applied to a type. This includes retrieving tool definitions, counting tools, and finding a specific tool by name.

```rust
use tokitai_core::ToolProvider;
// After `#[tool]` on a type:
// let tools = Calculator::tool_definitions();
// let count = Calculator::tool_count();
// let tool  = Calculator::find_tool("add");
```

--------------------------------

### ToolConfigRegistry::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolConfigRegistry.html?search=

Creates a new, empty registry for tool configurations. This is the starting point for managing tool settings.

```APIDOC
## ToolConfigRegistry::new

### Description
Creates a new empty registry.

### Returns
A new `ToolConfigRegistry` instance.

### Example
```rust
use tokitai_core::ToolConfigRegistry;

let registry = ToolConfigRegistry::new();
assert!(!registry.has_config("any_tool"));
```
```

--------------------------------

### ToolConfig Usage Examples

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=

Demonstrates how to use the ToolConfig enum to override tool descriptions and add per-parameter metadata for JSON schema generation.

```rust
use tokitai_core::ToolConfig;

// Override the description of a tool:
let c1 = ToolConfig::Desc("Look up a user by id".to_string());

// Add per-parameter metadata to the generated JSON Schema:
let c2 = ToolConfig::ParamMin {
    name: "age".to_string(),
    min: 0.0,
};
```

--------------------------------

### Example Usage of ToolError

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolError.html?search=

Demonstrates how to create and assert properties of a ToolError instance, specifically a validation error.

```rust
use tokitai_core::{ToolError, ToolErrorKind};

let error = ToolError::validation_error("Missing required parameter 'city'");
assert_eq!(error.kind, ToolErrorKind::ValidationError);
```

--------------------------------

### Example Tool Definitions JSON Output

Source: https://docs.rs/tokitai/latest/src/tokitai/lib.rs.html?search=std%3A%3Avec

This JSON represents the structure of the tools that can be sent to an AI. It includes the tool name, description, and input schema.

```json
[
  {
    "name": "add",
    "description": "Add two numbers together",
    "input_schema": "{\"type\":\"object\",\"properties\":{\"a\":{\"type\":\"integer\"},\"b\":{\"type\":\"integer\"}},\"required\":[\"a\",\"b\"]}"
  },
  {
    "name": "sha256",
    "description": "Calculate SHA256 hash of a string",
    "input_schema": "{\"type\":\"object\",\"properties\":{\"input\":{\"type\":\"string\"}},\"required\":[\"input\"]}"
  }
]
```

--------------------------------

### Example Usage within tool Macro

Source: https://docs.rs/tokitai/latest/tokitai/attr.tool_transform.html?search=u32+-%3E+bool

Demonstrates the internal usage of 'tool_transform' for parameter transformation, specifically converting an email string to lowercase. This is processed by the 'tool' macro.

```rust
#[tool]
impl MyTools {
    pub fn create_user(
        &self,
        #[tool_transform = "value.to_lowercase()")
        email: String,
    ) -> Result<String, Error> {
        // ...
    }
}
```

--------------------------------

### Example JSON Output of Tool Definitions

Source: https://docs.rs/tokitai/latest/src/tokitai/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This JSON represents the structure of tool definitions generated by Tokitai, including the tool's name, description, and input schema.

```json
[
  {
    "name": "add",
    "description": "Add two numbers together",
    "input_schema": "{\"type\":\"object\",\"properties\":{\"a\":{\"type\":\"integer\"},\"b\":{\"type\":\"integer\"}},\"required\":[\"a\",\"b\"]}"
  },
  {
    "name": "sha256",
    "description": "Calculate SHA256 hash of a string",
    "input_schema": "{\"type\":\"object\",\"properties\":{\"input\":{\"type\":\"string\"}},\"required\":[\"input\"]}"
  }
]

```

--------------------------------

### ParamType from_rust_type Method Examples

Source: https://docs.rs/tokitai/latest/tokitai/enum.ParamType.html?search=u32+-%3E+bool

Shows how to map Rust type names to ParamType variants. Returns None for Option<T> types.

```rust
use tokitai_core::ParamType;

assert_eq!(ParamType::from_rust_type("String"), Some(ParamType::String));
assert_eq!(ParamType::from_rust_type("i32"), Some(ParamType::Integer));
assert_eq!(ParamType::from_rust_type("f64"), Some(ParamType::Number));
assert_eq!(ParamType::from_rust_type("bool"), Some(ParamType::Boolean));
assert_eq!(ParamType::from_rust_type("Vec<i32>"), Some(ParamType::Array));
```

--------------------------------

### Get Tool Definitions for AI

Source: https://docs.rs/tokitai/latest/index.html

Generate compile-time tool definitions from your `#[tool]` annotated struct. Convert these definitions to JSON to send to an AI service.

```rust
// Compile-time generated tool definitions
let tools = Calculator::tool_definitions();

// Convert to JSON and send to AI
let tools_json = serde_json::to_string_pretty(tools)?;
println!("{}", tools_json);

```

--------------------------------

### Get and Convert Tool Definitions to JSON

Source: https://docs.rs/tokitai/latest/src/tokitai/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieve compile-time generated tool definitions from your struct and convert them to a JSON string to send to an AI service.

```rust
#[allow(unused_imports)]
use tokitai::tool;

// Assuming Calculator struct and #[tool] impl are defined as above

// Compile-time generated tool definitions
let tools = Calculator::tool_definitions();

// Convert to JSON and send to AI
let tools_json = serde_json::to_string_pretty(tools)?;
println!("{}", tools_json);

```

--------------------------------

### Get Tool Definitions for AI

Source: https://docs.rs/tokitai/latest/src/tokitai/lib.rs.html?search=std%3A%3Avec

Call the `tool_definitions()` method generated by the `#[tool]` macro to obtain a list of available tools. This list can be serialized to JSON and sent to an AI service.

```rust
// Compile-time generated tool definitions
let tools = Calculator::tool_definitions();

// Convert to JSON and send to AI
let tools_json = serde_json::to_string_pretty(tools)?;
println!("{}", tools_json);
```

--------------------------------

### Example Usage of tool_transform within tool Macro

Source: https://docs.rs/tokitai/latest/tokitai/attr.tool_transform.html?search=std%3A%3Avec

Demonstrates the internal usage of `#[tool_transform]` for parameter modification, specifically converting an email string to lowercase. This is processed by the `#[tool]` macro.

```rust
#[tool]
impl MyTools {
    pub fn create_user(
        &self,
        #[tool_transform = "value.to_lowercase()"]
        email: String,
    ) -> Result<String, Error> {
        // ...
    }
}
```

--------------------------------

### Check and Get JSON Array

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Use `as_array` to get a reference to the vector if the Value is an array. Returns `None` otherwise.

```rust
let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });

// The length of `["an", "array"]` is 2 elements.
assert_eq!(v["a"].as_array().unwrap().len(), 2);

// The object `{"an": "object"}` is not an array.
assert_eq!(v["b"].as_array(), None);
```

--------------------------------

### Check and Get Mutable JSON Array

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Use `as_array_mut` to get a mutable reference to the vector if the Value is an array. Returns `None` otherwise.

```rust
let mut v = json!({ "a": ["an", "array"] });

v["a"].as_array_mut().unwrap().clear();
assert_eq!(v, json!({ "a": [] }));
```

--------------------------------

### tokitai::config Macro Usage

Source: https://docs.rs/tokitai/latest/tokitai/macro.config.html

Demonstrates how to use the tokitai::config macro to define configuration for a service, including method descriptions, tags, and parameter details. This is useful for centrally managing tool properties.

```rust
tokitai::config! {
    MyService {
        get_user: {
            desc: "Fetch user info",
            tags: ["user", "read"],
            params: {
                id: {
                    desc: "User unique identifier",
                    example: "1001"
                }
            }
        }
    }
}
```

--------------------------------

### Accessing JSON Object/Array Elements with get()

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Shows how to access values within a JSON object by string key or within a JSON array by usize index using the `get` method. Returns `None` if the index is invalid or the type does not match.

```rust
let object = json!({ "A": 65, "B": 66, "C": 67 });
assert_eq!(*object.get("A").unwrap(), json!(65));

let array = json!([ "A", "B", "C" ]);
assert_eq!(*array.get(2).unwrap(), json!("C"));

assert_eq!(array.get("A"), None);
```

--------------------------------

### TypeId

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html

Gets the `TypeId` of `self`. This is useful for runtime type identification.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Returns
- `TypeId`: The unique identifier for the type of `self`.
```

--------------------------------

### Get Map Length

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html

Returns the total number of key-value pairs currently stored in the map.

```rust
pub fn len(&self) -> usize
```

--------------------------------

### ToolConfigRegistry::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolConfigRegistry.html

Creates a new, empty registry for tool configurations. This is the entry point for initializing a registry.

```APIDOC
## ToolConfigRegistry::new

### Description
Creates a new empty registry.

### Returns
A new instance of `ToolConfigRegistry`.

### Example
```rust
use tokitai_core::ToolConfigRegistry;

let registry = ToolConfigRegistry::new();
assert!(!registry.has_config("any_tool"));
```
```

--------------------------------

### CloneToUninit

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html

An experimental, nightly-only API for performing copy-assignment to uninitialized memory.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

### Method
N/A (Method on trait implementation)

### Endpoint
N/A

### Parameters
- **dest** (*mut u8) - A raw pointer to the destination memory location.

### Request Example
None

### Response
None (This is an unsafe operation that modifies memory directly).
```

--------------------------------

### Get Null Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Use `as_null` to retrieve the null value. It returns `Some(())` if the value is null, and `None` otherwise.

```Rust
let v = json!({ "a": null, "b": false });

assert_eq!(v["a"].as_null(), Some(()));

// The boolean `false` is not null.
assert_eq!(v["b"].as_null(), None);
```

--------------------------------

### CloneToUninit (Experimental)

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`

### Parameters
- `dest` (*mut u8): A mutable pointer to the destination memory location.

### Safety
This function is unsafe and requires the caller to ensure that `dest` is a valid, allocated memory location of sufficient size to hold the cloned value.
```

--------------------------------

### Create a new ToolDefinition

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html

Instantiates a new ToolDefinition with essential details like name, description, and input schema. This is useful for creating tools at runtime.

```rust
use tokitai_core::ToolDefinition;

let tool = ToolDefinition::new("add", "Add two numbers", r#"{"type":"object"}"#);
assert_eq!(tool.name, "add");
```

--------------------------------

### param_min

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a parameter minimum configuration for a given name and a minimum f64 value.

```APIDOC
## pub fn param_min<N>(name: N, min: f64) -> ToolConfig

### Description
Create a parameter minimum configuration.

### Parameters
#### Path Parameters
- **name** (N): The name of the parameter.
- **min** (f64): The minimum value for the parameter.

### Returns
- ToolConfig: A ToolConfig object with the parameter minimum configuration.
```

--------------------------------

### Get Entry for Manipulation

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html

Retrieves an entry for a given key, allowing for in-place manipulation. The key can be any type that can be converted into a String.

```rust
pub fn entry<S>(&mut self, key: S) -> Entry<'_>
where S: Into<String>,
```

--------------------------------

### Minimal Dependencies Configuration

Source: https://docs.rs/tokitai/latest/index.html

Configure tokitai to use only compile-time features, excluding runtime support. This reduces dependencies if runtime features like `call_tool` are not needed.

```toml
[dependencies]
tokitai = { version = "0.5", default-features = false }

```

--------------------------------

### impl Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Provides methods for interacting with the Value enum, such as getting or setting values by index, and checking the type of the value.

```APIDOC
## impl Value

### pub fn get<I>(&self, index: I) -> Option<&Value>

Index into a JSON array or map. A string index can be used to access a value in a map, and a usize index can be used to access an element of an array.

Returns `None` if the type of `self` does not match the type of the index, for example if the index is a string and `self` is an array or a number. Also returns `None` if the given key does not exist in the map or the given index is not within the bounds of the array.

Square brackets can also be used to index into a value in a more concise way. This returns `Value::Null` in cases where `get` would have returned `None`.

### pub fn get_mut<I>(&mut self, index: I) -> Option<&mut Value>

Mutably index into a JSON array or map. A string index can be used to access a value in a map, and a usize index can be used to access an element of an array.

Returns `None` if the type of `self` does not match the type of the index, for example if the index is a string and `self` is an array or a number. Also returns `None` if the given key does not exist in the map or the given index is not within the bounds of the array.

### pub fn is_object(&self) -> bool

Returns true if the `Value` is an Object. Returns false otherwise.
For any Value on which `is_object` returns true, `as_object` and `as_object_mut` are guaranteed to return the map representation of the object.

### pub fn as_object(&self) -> Option<&Map<String, Value>>

If the `Value` is an Object, returns the associated Map. Returns None otherwise.

### pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>>

If the `Value` is an Object, returns the associated mutable Map. Returns None otherwise.

### pub fn is_array(&self) -> bool

Returns true if the `Value` is an Array. Returns false otherwise.
For any Value on which `is_array` returns true, `as_array` and `as_array_mut` are guaranteed to return the vector representing the array.
```

--------------------------------

### ToolErrorKind Usage Example

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolErrorKind.html?search=u32+-%3E+bool

Demonstrates basic comparison between different variants of the ToolErrorKind enum. Ensure you import ToolErrorKind from tokitai_core.

```rust
use tokitai_core::ToolErrorKind;

// The four classifications:
assert_ne!(ToolErrorKind::ValidationError, ToolErrorKind::NotFound);
assert_ne!(ToolErrorKind::InternalError, ToolErrorKind::TypeError);
```

--------------------------------

### Get Key-Value Pair

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html

Retrieves the key and a reference to the value for the matching key. The key can be a borrowed form of the map's key type.

```rust
pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&String, &Value)>
where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized,
```

--------------------------------

### Get Value by Key

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html

Retrieves a reference to the value associated with a given key. The key can be a borrowed form of the map's key type.

```rust
pub fn get<Q>(&self, key: &Q) -> Option<&Value>
where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized,
```

--------------------------------

### Tokitai Minimal Dependencies

Source: https://docs.rs/tokitai/latest/src/tokitai/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Specifies the minimal dependencies for compile-time tool definitions without runtime support. This configuration excludes default features, which typically include runtime-related functionalities like serde/serde_json.

```toml
[dependencies]
tokitai = { version = "0.5", default-features = false }
```

--------------------------------

### Creating AiToolError Instances

Source: https://docs.rs/tokitai/latest/tokitai/error/enum.AiToolError.html

Demonstrates how to instantiate ValidationError and NotFound variants of AiToolError.

```rust
use tokitai::AiToolError;

// Validation error
let err = AiToolError::ValidationError {
    message: "Missing required parameter 'city'".to_string(),
};

// Tool not found
let err = AiToolError::NotFound {
    name: "unknown_tool".to_string(),
};
```

--------------------------------

### Get Boolean Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Use `as_bool` to safely retrieve the boolean value from a JSON Value. It returns `Some(bool)` if the value is a boolean, and `None` otherwise.

```Rust
let v = json!({ "a": false, "b": "false" });

assert_eq!(v["a"].as_bool(), Some(false));

// The string "false" is a string, not a boolean.
assert_eq!(v["b"].as_bool(), None);
```

--------------------------------

### Create ToolDefinition with new()

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html?search=std%3A%3Avec

Creates a new tool definition at runtime. Each argument can be any type that implements `Into<String>`.

```rust
use tokitai_core::ToolDefinition;

let tool = ToolDefinition::new(
    "get_weather",
    "Get weather information for a specified city",
    r#"{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}"#
);
```

--------------------------------

### ToolDefinition::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html

Creates a new tool definition at runtime. Arguments can be any type that implements `Into<String>`.

```APIDOC
## ToolDefinition::new

### Description
Create a new tool definition at runtime. Each argument can be any type that implements `Into<String>`.

### Signature
```rust
pub fn new( name: impl Into<String>, description: impl Into<String>, input_schema: impl Into<String>, ) -> ToolDefinition
```

### Example
```rust
use tokitai_core::ToolDefinition;

let tool = ToolDefinition::new(
    "get_weather",
    "Get weather information for a specified city",
    r#"{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}"#
);
```
```

--------------------------------

### Map<String, Value> Methods

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html?search=

Provides documentation for various methods available on the `Map<String, Value>` struct, including creation, access, modification, and iteration.

```APIDOC
## Map<String, Value>

Represents a JSON key/value type.

### Methods

#### `new()`

- **Description**: Makes a new empty Map.
- **Signature**: `pub fn new() -> Map<String, Value>`

#### `with_capacity(capacity: usize)`

- **Description**: Makes a new empty Map with the given initial capacity.
- **Signature**: `pub fn with_capacity(capacity: usize) -> Map<String, Value>`

#### `clear()`

- **Description**: Clears the map, removing all values.
- **Signature**: `pub fn clear(&mut self)`

#### `get<Q>(key: &Q)`

- **Description**: Returns a reference to the value corresponding to the key. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.
- **Signature**: `pub fn get<Q>(&self, key: &Q) -> Option<&Value> where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized`

#### `contains_key<Q>(key: &Q)`

- **Description**: Returns true if the map contains a value for the specified key. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.
- **Signature**: `pub fn contains_key<Q>(&self, key: &Q) -> bool where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized`

#### `get_mut<Q>(key: &Q)`

- **Description**: Returns a mutable reference to the value corresponding to the key. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.
- **Signature**: `pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut Value> where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized`

#### `get_key_value<Q>(key: &Q)`

- **Description**: Returns the key-value pair matching the given key. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.
- **Signature**: `pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&String, &Value)> where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized`

#### `insert(k: String, v: Value)`

- **Description**: Inserts a key-value pair into the map. If the map did not have this key present, `None` is returned. If the map did have this key present, the value is updated, and the old value is returned.
- **Signature**: `pub fn insert(&mut self, k: String, v: Value) -> Option<Value>`

#### `remove<Q>(key: &Q)`

- **Description**: Removes a key from the map, returning the value at the key if the key was previously in the map. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type. If serde_json’s “preserve_order” is enabled, `.remove(key)` is equivalent to `.swap_remove(key)`, replacing this entry’s position with the last element. If you need to preserve the relative order of the keys in the map, use `.shift_remove(key)` instead.
- **Signature**: `pub fn remove<Q>(&mut self, key: &Q) -> Option<Value> where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized`

#### `remove_entry<Q>(key: &Q)`

- **Description**: Removes a key from the map, returning the stored key and value if the key was previously in the map. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type. If serde_json’s “preserve_order” is enabled, `.remove_entry(key)` is equivalent to `.swap_remove_entry(key)`, replacing this entry’s position with the last element. If you need to preserve the relative order of the keys in the map, use `.shift_remove_entry(key)` instead.
- **Signature**: `pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(String, Value)> where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized`

#### `append(other: &mut Map<String, Value>)`

- **Description**: Moves all elements from other into self, leaving other empty.
- **Signature**: `pub fn append(&mut self, other: &mut Map<String, Value>)`

#### `entry<S>(key: S)`

- **Description**: Gets the given key’s corresponding entry in the map for in-place manipulation.
- **Signature**: `pub fn entry<S>(&mut self, key: S) -> Entry<'_> where S: Into<String>`

#### `len()`

- **Description**: Returns the number of elements in the map.
- **Signature**: `pub fn len(&self) -> usize`

#### `is_empty()`

- **Description**: Returns true if the map contains no elements.
- **Signature**: `pub fn is_empty(&self) -> bool`

#### `iter()`

- **Description**: Gets an iterator over the entries of the map.
- **Signature**: `pub fn iter(&self) -> Iter<'_>`

#### `iter_mut()`

- **Description**: Gets a mutable iterator over the entries of the map.
- **Signature**: `pub fn iter_mut(&mut self) -> IterMut<'_>`

#### `keys()`

- **Description**: Gets an iterator over the keys of the map.
- **Signature**: `pub fn keys(&self) -> Keys<'_>`

#### `values()`

- **Description**: Gets an iterator over the values of the map.
- **Signature**: `pub fn values(&self) -> Values<'_>`

#### `values_mut()`

- **Description**: Gets an iterator over mutable values of the map.
- **Signature**: `pub fn values_mut(&mut self) -> ValuesMut<'_>`

#### `into_values()`

- **Description**: Gets an iterator over the values of the map.
- **Signature**: `pub fn into_values(self) -> IntoValues`

#### `retain<F>(f: F)`

- **Description**: Retains only the elements specified by the predicate. In other words, remove all pairs `(k, v)` such that `f(&k, &mut v)` returns `false`.
- **Signature**: `pub fn retain<F>(&mut self, f: F) where F: FnMut(&String, &mut Value) -> bool`
```

--------------------------------

### Apply Runtime Configurations to ToolDefinition

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html?search=std%3A%3Avec

Applies a list of runtime configuration items to an existing ToolDefinition. This is useful for overriding compile-time defaults.

```rust
use tokitai_core::{ToolDefinition, ToolConfig};

let mut tool = ToolDefinition::new("test", "Original description", "{}");
tool.apply_configs(&[
    ToolConfig::Desc("Overridden description".to_string()),
]);
assert_eq!(tool.description, "Overridden description");
```

--------------------------------

### Creating a JSON String Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Demonstrates how to create a JSON string value using the json! macro.

```rust
let v = json!("a string");
```

--------------------------------

### Get Mutable Value by Key

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html

Retrieves a mutable reference to the value associated with a given key. The key can be a borrowed form of the map's key type.

```rust
pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut Value>
where String: Borrow<Q>, Q: Ord + Eq + Hash + ?Sized,
```

--------------------------------

### Map::contains_key

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Checks if the map contains a value for the specified key. Similar to `get`, the key can be borrowed, and its ordering must align with the map's key type.

```APIDOC
## Map::contains_key

### Description
Returns true if the map contains a value for the specified key. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form _must_ match the ordering on the key type.

### Method
`contains_key<Q>(&self, key: &Q) -> bool`

### Parameters
#### Path Parameters
- **key** (&Q) - Required - The key to check for. `Q` must implement `Ord`, `Eq`, and `Hash`, and `String` must implement `Borrow<Q>`.
```

--------------------------------

### tokitai::config! Macro Definition

Source: https://docs.rs/tokitai/latest/tokitai/macro.config.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The basic definition of the `config` proc-macro in tokitai.

```rust
config!() { /* proc-macro */ }
```

--------------------------------

### tokitai Value::eq Function Signature

Source: https://docs.rs/tokitai/latest/tokitai/attr.tool_multiple_of.html?search=u32+-%3E+bool

Example of a function signature that uses the Value::eq method, which returns a boolean indicating if a value is a multiple of a given u32.

```rust
Value::eq(&Value, &**u32**) -> bool

```

--------------------------------

### ToolDefinition::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html?search=std%3A%3Avec

Creates a new ToolDefinition instance at runtime. Accepts any type that implements `Into<String>` for its arguments, allowing for flexible string conversions.

```APIDOC
## pub fn new( name: impl Into<String>, description: impl Into<String>, input_schema: impl Into<String>, ) -> ToolDefinition

Create a new tool definition at runtime. Each argument can be any type that implements `Into<String>`.

### Example

```rust
use tokitai_core::ToolDefinition;

let tool = ToolDefinition::new(
    "get_weather",
    "Get weather information for a specified city",
    r#"{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}"#
);
```
```

--------------------------------

### Basic param_tool Usage

Source: https://docs.rs/tokitai/latest/tokitai/attr.param_tool.html?search=std%3A%3Avec

Demonstrates how to apply `param_tool` attributes for validation, transformation, and default values to function parameters. This snippet is part of a larger `#[tool]` implementation.

```rust
#[tool]
impl MyTools {
    pub fn create_user(
        &self,
        #[param_tool(validate = "!value.is_empty()", desc = "Name cannot be empty")]
        name: String,
        #[param_tool(transform = "value.to_lowercase()") ]
        email: String,
        #[param_tool(default = 10)]
        count: i32,
    ) -> Result<String, Error> {
        // ...
    }
}
```

--------------------------------

### Get Boolean Value from Serde JSON

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=std%3A%3Avec

Use `as_bool` to safely retrieve the boolean value from a Serde JSON Value. It returns `Some(bool)` if the value is a boolean, and `None` otherwise.

```rust
let v = json!({ "a": false, "b": "false" });

assert_eq!(v["a"].as_bool(), Some(false));

// The string \"false\" is a string, not a boolean.
assert_eq!(v["b"].as_bool(), None);
```

--------------------------------

### Add Tokitai Dependency

Source: https://docs.rs/tokitai/latest/index.html

Add the tokitai crate to your project's Cargo.toml file. Required dependencies like serde, serde_json, and thiserror are included automatically.

```toml
[dependencies]
tokitai = "0.5"

```

--------------------------------

### Get Value by Key

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html?search=u32+-%3E+bool

Retrieves an immutable reference to a value associated with a given key. The key can be a borrowed form of the map's key type, provided its ordering matches.

```rust
pub fn get<Q>(&self, key: &Q) -> Option<&Value>
where
    String: Borrow<Q>,
    Q: Ord + Eq + Hash + ?Sized,
```

--------------------------------

### ToolDefinition::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html?search=u32+-%3E+bool

Creates a new tool definition at runtime. Accepts any type that can be converted into a String for name, description, and input schema.

```APIDOC
## ToolDefinition::new

### Description
Create a new tool definition at runtime. Each argument can be any type that implements `Into<String>`.

### Signature
```rust
pub fn new( name: impl Into<String>, description: impl Into<String>, input_schema: impl Into<String>, ) -> ToolDefinition
```

### Parameters
* **name** (impl Into<String>) - The name of the tool.
* **description** (impl Into<String>) - A description of the tool's purpose.
* **input_schema** (impl Into<String>) - The JSON Schema for the tool's input parameters.

### Returns
A new `ToolDefinition` instance.

### Example
```rust
use tokitai_core::ToolDefinition;

let tool = ToolDefinition::new(
    "get_weather",
    "Get weather information for a specified city",
    r#"{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}"#
);
```
```

--------------------------------

### Extract Number Reference from JSON Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Use `as_number` to get a reference to the `Number` if the Value is a number. Returns `None` otherwise. Handles integers, floats, and negative numbers.

```rust
let v = json!({ "a": 1, "b": 2.2, "c": -3, "d": "4" });

assert_eq!(v["a"].as_number(), Some(&Number::from(1u64)));
assert_eq!(v["b"].as_number(), Some(&Number::from_f64(2.2).unwrap()));
assert_eq!(v["c"].as_number(), Some(&Number::from(-3i64)));

// The string `"4"` is not a number.
assert_eq!(v["d"].as_number(), None);
```

--------------------------------

### Create NotFound Error

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolError.html?search=

Demonstrates creating a ToolError for cases where a tool is not found.

```rust
use tokitai_core::{ToolError, ToolErrorKind};

let err = ToolError::not_found("unknown_tool");
assert_eq!(err.kind, ToolErrorKind::NotFound);
```

--------------------------------

### Map::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new, empty Map. This is the primary way to initialize an empty map for storing string-keyed JSON values.

```APIDOC
## Map::new

### Description
Creates a new, empty Map. This is the primary way to initialize an empty map for storing string-keyed JSON values.

### Method
`new()`

### Returns
- `Map<String, Value>` - An empty Map instance.
```

--------------------------------

### param_min_length

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a parameter minimum length configuration for a given name and a minimum u64 length.

```APIDOC
## pub fn param_min_length<N>(name: N, min_length: u64) -> ToolConfig

### Description
Create a parameter minimum length configuration.

### Parameters
#### Path Parameters
- **name** (N): The name of the parameter.
- **min_length** (u64): The minimum length for the parameter.

### Returns
- ToolConfig: A ToolConfig object with the parameter minimum length configuration.
```

--------------------------------

### Create ToolDefinition from compile-time constants

Source: https://docs.rs/tokitai/latest/tokitai/struct.ToolDefinition.html?search=std%3A%3Avec

Builds a tool definition from compile-time constants, optimized for the `#[tool]` macro with no allocation, just `'static` to owned-string copies.

```rust
use tokitai_core::{ToolDefinition, ToolDefinitionConst};

const TOOL_DATA: ToolDefinitionConst = ToolDefinitionConst {
    name: "get_weather",
    description: "Get weather information for a specified city",
    input_schema: r#"{"type":"object"}"#.to_owned(),
};

let tool = ToolDefinition::from_const(TOOL_DATA);
```

--------------------------------

### ToolConfig Enum Definition

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=

Defines the structure of the ToolConfig enum, which includes variants for setting tool descriptions, tags, and various parameter metadata like descriptions, examples, defaults, and constraints.

```rust
pub enum ToolConfig {
Show 14 variants    Desc(String),
    Tags(Vec<String>),
    ParamDesc {
        name: String,
        desc: String,
    },
    ParamExample {
        name: String,
        example: Value,
    },
    ParamDefault {
        name: String,
        default: Value,
    },
    ParamRequired {
        name: String,
        required: bool,
    },
    ParamMin {
        name: String,
        min: f64,
    },
    ParamMax {
        name: String,
        max: f64,
    },
    ParamMinLength {
        name: String,
        min_length: u64,
    },
    ParamMaxLength {
        name: String,
        max_length: u64,
    },
    ParamPattern {
        name: String,
        pattern: String,
    },
    ParamMinItems {
        name: String,
        min_items: u64,
    },
    ParamMaxItems {
        name: String,
        max_items: u64,
    },
    ParamMultipleOf {
        name: String,
        multiple_of: f64,
    },
}
```

--------------------------------

### Map::new

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html?search=u32+-%3E+bool

Creates a new, empty `Map<String, Value>`.

```APIDOC
## Map::new

### Description
Creates a new empty Map.

### Method
`new()`

### Returns
- `Map<String, Value>`: A new empty map.
```

--------------------------------

### Internal Usage Example of tool_validate

Source: https://docs.rs/tokitai/latest/tokitai/attr.tool_validate.html

Demonstrates the internal usage of the tool_validate attribute within the tool macro for parameter validation. This is processed by the #[tool] macro and not meant for direct user calls.

```rust
#[tool]
impl MyTools {
    pub fn create_user(
        &self,
        #[tool_validate = "!value.is_empty()"]
        name: String,
    ) -> Result<String, Error> {
        // ...
    }
}
```

--------------------------------

### Mutably Access Value by JSON Pointer

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Use `pointer_mut` to get a mutable reference to a nested JSON value via a JSON Pointer. This allows in-place modification or taking ownership of the value.

```Rust
use serde_json::Value;

fn main() {
    let s = r#"{"x": 1.0, "y": 2.0}"#;
    let mut value: Value = serde_json::from_str(s).unwrap();

    // Check value using read-only pointer
    assert_eq!(value.pointer("/x"), Some(&1.0.into()));
    // Change value with direct assignment
    *value.pointer_mut("/x").unwrap() = 1.5.into();
    // Check that new value was written
    assert_eq!(value.pointer("/x"), Some(&1.5.into()));
    // Or change the value only if it exists
    value.pointer_mut("/x").map(|v| *v = 1.5.into());

    // "Steal" ownership of a value. Can replace with any valid Value.
    let old_x = value.pointer_mut("/x").map(Value::take).unwrap();
    assert_eq!(old_x, 1.5);
    assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
}
```

--------------------------------

### Creating a JSON Array Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Demonstrates how to create a JSON array value using the json! macro.

```rust
let v = json!(["an", "array"]);
```

--------------------------------

### Create Parameter Description Configuration

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=

Use this function to create a `ToolConfig::ParamDesc` variant, which overrides the description of a specific parameter. It requires the parameter name and the new description.

```rust
use tokitai_core::ToolConfig;

let c = ToolConfig::param_desc("id", "User identifier");
assert!(matches!(c, ToolConfig::ParamDesc { .. }));
```

--------------------------------

### Access Map Element by Index

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html

Accesses an element within a Value enum, specifically handling the Value::Object variant by indexing into its map. This example demonstrates pattern matching to safely extract string slices.

```rust
match val {
    Value::String(s) => Some(s.as_str()),
    Value::Array(arr) => arr[0].as_str(),
    Value::Object(map) => map["type"].as_str(),
    _ => None,
}
```

--------------------------------

### Creating a JSON Object Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Demonstrates how to create a JSON object value using the json! macro. By default, objects are backed by BTreeMap.

```rust
let v = json!({ "an": "object" });
```

--------------------------------

### Extract String Slice from JSON Value

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Use `as_str` to get a string slice if the Value is a string. Returns `None` otherwise. Note the difference in printing JSON strings (with quotes) versus Rust string slices (without quotes).

```rust
let v = json!({ "a": "some string", "b": false });

assert_eq!(v["a"].as_str(), Some("some string"));

// The boolean `false` is not a string.
assert_eq!(v["b"].as_str(), None);

// JSON values are printed in JSON representation, so strings are in quotes.
//
//    The value is: "some string"
println!("The value is: {}", v["a"]);

// Rust strings are printed without quotes.
//
//    The value is: some string
println!("The value is: {}", v["a"].as_str().unwrap());
```

--------------------------------

### Map Creation

Source: https://docs.rs/tokitai/latest/tokitai/struct.Map.html

Methods for creating new Map instances, either empty or with a specified capacity.

```APIDOC
## Map Creation

### `new()`

Creates a new empty Map.

### `with_capacity(capacity: usize)`

Creates a new empty Map with the given initial capacity.
```

--------------------------------

### Accessing JSON Elements with Square Brackets

Source: https://docs.rs/tokitai/latest/tokitai/enum.Value.html?search=

Illustrates using square bracket notation for concise access to JSON object properties or array elements. This returns `Value::Null` for non-existent keys or indices, unlike `get()` which returns `None`.

```rust
let object = json!({
    "A": ["a", "á", "à"],
    "B": ["b", "b́"],
    "C": ["c", "ć", "ć̣", "ḉ"],
});
assert_eq!(object["B"][0], json!("b"));

assert_eq!(object["D"], json!(null));
assert_eq!(object[0]["x"]["y"]["z"], json!(null));
```

--------------------------------

### param_multiple_of

Source: https://docs.rs/tokitai/latest/tokitai/enum.ToolConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a parameter multiple of configuration for a given name and a multiple f64 value.

```APIDOC
## pub fn param_multiple_of<N>(name: N, multiple_of: f64) -> ToolConfig

### Description
Create a parameter multiple of configuration.

### Parameters
#### Path Parameters
- **name** (N): The name of the parameter.
- **multiple_of** (f64): The multiple of value for the parameter.

### Returns
- ToolConfig: A ToolConfig object with the parameter multiple of configuration.
```
Tokens:
Raw