Interface IAgentTool<T>

Interface representing a tool used by an agent, extending the base ITool interface. Defines the tool's execution and validation logic, with optional lifecycle callbacks.

interface IAgentTool<T = Record<string, ToolValue>> {
    call(
        dto: {
            abortSignal: TAbortSignal;
            agentName: string;
            callReason: string;
            clientId: string;
            isLast: boolean;
            params: T;
            toolCalls: IToolCall[];
            toolId: string;
            toolName: string;
        },
    ): Promise<void>;
    callbacks?: Partial<IAgentToolCallbacks<Record<string, ToolValue>>>;
    docNote?: string;
    function:
        | {
            description: string;
            name: string;
            parameters: {
                properties: {
                    [key: string]: {
                        description: string;
                        enum?: string[];
                        type: string;
                    };
                };
                required: string[];
                type: string;
            };
        }
        | (
            clientId: string,
            agentName: string,
        ) =>
            | {
                description: string;
                name: string;
                parameters: {
                    properties: {
                        [key: string]: {
                            description: string;
                            enum?: string[];
                            type: string;
                        };
                    };
                    required: string[];
                    type: string;
                };
            }
            | Promise<
                {
                    description: string;
                    name: string;
                    parameters: {
                        properties: {
                            [key: string]: {
                                description: string;
                                enum?: string[];
                                type: string;
                            };
                        };
                        required: string[];
                        type: string;
                    };
                },
            >;
    isAvailable?: (
        clientId: string,
        agentName: string,
        toolName: string,
    ) => boolean | Promise<boolean>;
    toolName: string;
    type: string;
    validate?: (
        dto: {
            agentName: string;
            clientId: string;
            params: T;
            toolCalls: IToolCall[];
        },
    ) => boolean
    | Promise<boolean>;
}

Type Parameters

  • T = Record<string, ToolValue>

    The type of the parameters for the tool, defaults to a record of ToolValue.

Properties

callbacks? docNote? function isAvailable? toolName type validate?

Methods

call

Properties

Optionalcallbacks

callbacks?: Partial<IAgentToolCallbacks<Record<string, ToolValue>>>

Optional lifecycle callbacks for the tool, allowing customization of execution flow.

OptionaldocNote

docNote?: string

Optional description for documentation purposes, aiding in tool usage understanding.

function

function:
    | {
        description: string;
        name: string;
        parameters: {
            properties: {
                [key: string]: { description: string; enum?: string[]; type: string };
            };
            required: string[];
            type: string;
        };
    }
    | (
        clientId: string,
        agentName: string,
    ) =>
        | {
            description: string;
            name: string;
            parameters: {
                properties: {
                    [key: string]: {
                        description: string;
                        enum?: string[];
                        type: string;
                    };
                };
                required: string[];
                type: string;
            };
        }
        | Promise<
            {
                description: string;
                name: string;
                parameters: {
                    properties: {
                        [key: string]: {
                            description: string;
                            enum?: string[];
                            type: string;
                        };
                    };
                    required: string[];
                    type: string;
                };
            },
        >

Optional dynamic factory to resolve tool metadata

Type declaration

  • {
        description: string;
        name: string;
        parameters: {
            properties: {
                [key: string]: { description: string; enum?: string[]; type: string };
            };
            required: string[];
            type: string;
        };
    }
    • description: string

      A human-readable description of the function’s purpose. Informs the model or users about the tool's functionality (e.g., "Performs a search query"), used in tool selection or documentation. Not directly executed but critical for model understanding in ClientAgent workflows.

    • name: string

      The name of the function, uniquely identifying the tool. Must match IToolCall.function.name for execution (e.g., "search" in ClientAgent.tools), serving as the key for tool lookup and invocation. Example: "calculate" for a math tool.

    • parameters: {
          properties: {
              [key: string]: { description: string; enum?: string[]; type: string };
          };
          required: string[];
          type: string;
      }

      The schema defining the parameters required by the function. Specifies the structure, types, and constraints of arguments (e.g., IToolCall.function.arguments), validated in ClientAgent (e.g., targetFn.validate). Provides the model with a blueprint for generating valid tool calls.

      • properties: { [key: string]: { description: string; enum?: string[]; type: string } }

        A key-value map defining the properties of the parameters. Details each argument’s type, description, and optional constraints, guiding the model and agent in constructing and validating tool calls (e.g., in ClientAgent.EXECUTE_FN).

      • required: string[]

        An array of parameter names that are mandatory for the function. Lists keys that must be present in IToolCall.function.arguments, enforced during validation (e.g., ClientAgent.targetFn.validate). Example: ["query"] for a search tool requiring a query string.

      • type: string

        The type of the parameters object, typically "object". Indicates that parameters are a key-value structure, as expected by IToolCall.function.arguments in ClientAgent. Example: "object" for a standard JSON-like parameter set.

  • (
        clientId: string,
        agentName: string,
    ) =>
        | {
            description: string;
            name: string;
            parameters: {
                properties: {
                    [key: string]: { description: string; enum?: string[]; type: string };
                };
                required: string[];
                type: string;
            };
        }
        | Promise<
            {
                description: string;
                name: string;
                parameters: {
                    properties: {
                        [key: string]: {
                            description: string;
                            enum?: string[];
                            type: string;
                        };
                    };
                    required: string[];
                    type: string;
                };
            },
        >

OptionalisAvailable

isAvailable?: (
    clientId: string,
    agentName: string,
    toolName: string,
) => boolean | Promise<boolean>

Checks if the tool is available for execution. This method can be used to determine if the tool can be executed based on the current context.

toolName

toolName: string

The unique name of the tool, used for identification within the agent swarm.

type

type: string

Tool type defenition. For now, should be function

Optionalvalidate

validate?: (
    dto: {
        agentName: string;
        clientId: string;
        params: T;
        toolCalls: IToolCall[];
    },
) => boolean
| Promise<boolean>

Validates the tool parameters before execution. Can return synchronously or asynchronously based on validation complexity.

Methods

call

  • call(
        dto: {
            abortSignal: TAbortSignal;
            agentName: string;
            callReason: string;
            clientId: string;
            isLast: boolean;
            params: T;
            toolCalls: IToolCall[];
            toolId: string;
            toolName: string;
        },
    ): Promise<void>

    Executes the tool with the specified parameters and context.

    Parameters

    • dto: {
          abortSignal: TAbortSignal;
          agentName: string;
          callReason: string;
          clientId: string;
          isLast: boolean;
          params: T;
          toolCalls: IToolCall[];
          toolId: string;
          toolName: string;
      }

    Returns Promise<void>

    Throws

    If the tool execution fails or parameters are invalid.

Settings

Member Visibility

On This Page

Properties
Methods