Get tool

GET https://api.elevenlabs.io/v1/convai/tools/

Get tool that is available in the workspace.

Reference: https://elevenlabs.io/docs/api-reference/tools/get

• https://api.elevenlabs.io (Production, default)
• https://api.us.elevenlabs.io (Production US)
• https://api.eu.residency.elevenlabs.io (Production EU)
• https://api.in.residency.elevenlabs.io (Production India)
• https://api.sg.residency.elevenlabs.io (Production Singapore)

• tool_id (string, required) — ID of the requested tool.

• environment (string, optional, default: production) — Environment whose values are used when the MCP server URL, headers, or auth connection reference environment variables. Mirrors the environment a conversation would run in; defaults to production.

Successful Response

• id (string, required)
• tool_config (ToolResponseModelToolConfig, required) — The type of tool
• access_info (ResourceAccessInfo, required)
• usage_stats (ToolUsageStatsResponseModel, required)
• response_mocks (list of ToolResponseMockConfig-Output, optional, nullable) — Mock responses with optional parameter conditions. Evaluated top-to-bottom; first match wins.

Validation Error

• detail (list of ValidationError, optional)

The type of tool

• type: client (ClientToolConfig)
  • description (string, required) — Description of when the tool should be used and what it does.
  • name (string, required)
  • assignments (list of DynamicVariableAssignment, optional) — Configuration for extracting values from tool responses and assigning them to dynamic variables
  • dynamic_variables (DynamicVariablesConfig, optional) — Configuration for dynamic variables
  • execution_mode (enum, optional, default: immediate) — Determines when and how the tool executes: 'immediate' executes the tool right away when requested by the LLM, 'post_tool_speech' waits for the agent to finish speaking before executing, 'async' runs the tool in the background without blocking - best for long-running operations.
    • Allowed values: immediate, post_tool_speech, async
  • expects_response (boolean, optional, default: false) — If true, calling this tool should block the conversation until the client responds with some response which is passed to the llm. If false then we will continue the conversation without waiting for the client to respond, this is useful to show content to a user but not block the conversation
  • interruption_mode (enum, optional, default: allow) — Controls whether the user can interrupt the agent around this tool call. 'allow' (default) lets the user interrupt at any time, 'disable_during_tool' suppresses interruptions only while the tool is running, 'disable_during_tool_and_turn' suppresses interruptions while the tool runs and for the agent response that follows it.
    • Allowed values: allow, disable_during_tool, disable_during_tool_and_turn
  • parameters (ObjectJsonSchemaProperty-Output, optional, nullable) — Schema for any parameters to pass to the client
  • pre_tool_speech (enum, optional, default: auto) — Controls whether the agent speaks before this tool is called. 'auto' (default) decides based on recent tool latency, 'force' always asks the agent to speak, 'off' fully opts out regardless of latency.
    • Allowed values: auto, force, off
  • response_timeout_secs (integer, optional, default: 20) — The maximum time in seconds to wait for the tool call to complete. Must be between 1 and 120 seconds (inclusive).
  • tool_call_sound (enum, optional, nullable) — Predefined tool call sound type to play during tool execution. If not specified, no tool call sound will be played.
    • Allowed values: typing, elevator1, elevator2, elevator3, elevator4
  • tool_call_sound_behavior (enum, optional, default: auto) — Determines when the tool call sound should play. 'auto' only plays when there's pre-tool speech, 'always' plays for every tool call.
    • Allowed values: auto, always
  • tool_error_handling_mode (enum, optional, default: auto) — Controls how tool errors are processed before being shared with the agent. 'auto' determines handling based on tool type (summarized for native integrations, hide for others), 'summarized' sends an LLM-generated summary, 'passthrough' sends the raw error, 'hide' does not share the error with the agent.
    • Allowed values: auto, summarized, passthrough, hide
  • disable_interruptions (boolean, optional, default: false, deprecated) — DEPRECATED: use interruption_mode instead. If true, the user will not be able to interrupt the agent while this tool is running.
  • force_pre_tool_speech (boolean, optional, default: false, deprecated) — DEPRECATED: use pre_tool_speech instead. If true, the agent will speak before the tool call.
• type: mcp (mcp)
• type: system (SystemToolConfig)
  • name (string, required)
  • params (ToolResponseModelToolConfigDiscriminatorMappingSystemParams, required)
  • assignments (list of DynamicVariableAssignment, optional) — Configuration for extracting values from tool responses and assigning them to dynamic variables
  • description (string, optional, default: ) — Description of when the tool should be used and what it does. Leave empty to use the default description that's optimized for the specific tool type.
  • interruption_mode (enum, optional, default: allow) — Controls whether the user can interrupt the agent around this tool call. 'allow' (default) lets the user interrupt at any time, 'disable_during_tool' suppresses interruptions only while the tool is running, 'disable_during_tool_and_turn' suppresses interruptions while the tool runs and for the agent response that follows it.
    • Allowed values: allow, disable_during_tool, disable_during_tool_and_turn
  • pre_tool_speech (enum, optional, default: auto) — Controls whether the agent speaks before this tool is called. 'auto' (default) decides based on recent tool latency, 'force' always asks the agent to speak, 'off' fully opts out regardless of latency.
    • Allowed values: auto, force, off
  • response_timeout_secs (integer, optional, default: 20) — The maximum time in seconds to wait for the tool call to complete.
  • tool_call_sound (enum, optional, nullable) — Predefined tool call sound type to play during tool execution. If not specified, no tool call sound will be played.
    • Allowed values: typing, elevator1, elevator2, elevator3, elevator4
  • tool_call_sound_behavior (enum, optional, default: auto) — Determines when the tool call sound should play. 'auto' only plays when there's pre-tool speech, 'always' plays for every tool call.
    • Allowed values: auto, always
  • tool_error_handling_mode (enum, optional, default: auto) — Controls how tool errors are processed before being shared with the agent. 'auto' determines handling based on tool type (summarized for native integrations, hide for others), 'summarized' sends an LLM-generated summary, 'passthrough' sends the raw error, 'hide' does not share the error with the agent.
    • Allowed values: auto, summarized, passthrough, hide
  • disable_interruptions (boolean, optional, default: false, deprecated) — DEPRECATED: use interruption_mode instead. If true, the user will not be able to interrupt the agent while this tool is running.
  • force_pre_tool_speech (boolean, optional, default: false, deprecated) — DEPRECATED: use pre_tool_speech instead. If true, the agent will speak before the tool call.
• type: webhook (WebhookToolConfig)
  • api_schema (WebhookToolApiSchemaConfig-Output, required) — The schema for the outgoing webhoook, including parameters and URL specification
  • description (string, required) — Description of when the tool should be used and what it does.
  • name (string, required)
  • assignments (list of DynamicVariableAssignment, optional) — Configuration for extracting values from tool responses and assigning them to dynamic variables
  • dynamic_variables (DynamicVariablesConfig, optional) — Configuration for dynamic variables
  • execution_mode (enum, optional, default: immediate) — Determines when and how the tool executes: 'immediate' executes the tool right away when requested by the LLM, 'post_tool_speech' waits for the agent to finish speaking before executing, 'async' runs the tool in the background without blocking - best for long-running operations.
    • Allowed values: immediate, post_tool_speech, async
  • follow_redirects (boolean, optional, default: false) — Whether to resolve a redirect from the endpoint and return the final response. One redirect is followed, as a GET without the request body; nothing configured on this tool (headers, authentication, client certificate) is sent to the redirect target. Both the endpoint and the redirect target must use HTTPS. Not supported for API integration tools.
  • follow_redirects_allowed_domains (list of string, optional) — Domains a redirect may point at, e.g. 'test.example.com'. Required when following redirects, and a target outside the list is refused.
  • interruption_mode (enum, optional, default: allow) — Controls whether the user can interrupt the agent around this tool call. 'allow' (default) lets the user interrupt at any time, 'disable_during_tool' suppresses interruptions only while the tool is running, 'disable_during_tool_and_turn' suppresses interruptions while the tool runs and for the agent response that follows it.
    • Allowed values: allow, disable_during_tool, disable_during_tool_and_turn
  • pre_tool_speech (enum, optional, default: auto) — Controls whether the agent speaks before this tool is called. 'auto' (default) decides based on recent tool latency, 'force' always asks the agent to speak, 'off' fully opts out regardless of latency.
    • Allowed values: auto, force, off
  • response_timeout_secs (integer, optional, default: 20) — The maximum time in seconds to wait for the tool call to complete. Must be between 5 and 300 seconds (inclusive).
  • tool_call_sound (enum, optional, nullable) — Predefined tool call sound type to play during tool execution. If not specified, no tool call sound will be played.
    • Allowed values: typing, elevator1, elevator2, elevator3, elevator4
  • tool_call_sound_behavior (enum, optional, default: auto) — Determines when the tool call sound should play. 'auto' only plays when there's pre-tool speech, 'always' plays for every tool call.
    • Allowed values: auto, always
  • tool_error_handling_mode (enum, optional, default: auto) — Controls how tool errors are processed before being shared with the agent. 'auto' determines handling based on tool type (summarized for native integrations, hide for others), 'summarized' sends an LLM-generated summary, 'passthrough' sends the raw error, 'hide' does not share the error with the agent.
    • Allowed values: auto, summarized, passthrough, hide
  • disable_interruptions (boolean, optional, default: false, deprecated) — DEPRECATED: use interruption_mode instead. If true, the user will not be able to interrupt the agent while this tool is running.
  • force_pre_tool_speech (boolean, optional, default: false, deprecated) — DEPRECATED: use pre_tool_speech instead. If true, the agent will speak before the tool call.

• is_creator (boolean, required) — Whether the user making the request is the creator of the agent
• creator_name (string, required) — Name of the agent's creator
• creator_email (string, required) — Email of the agent's creator
• role (enum, required) — The role of the user making the request
  • Allowed values: admin, editor, commenter, viewer
• anonymous_access_level_override (enum, optional, nullable) — The access level for anonymous users. If None, the resource is not shared publicly.
  • Allowed values: admin, editor, commenter, viewer
• access_source (enum, optional, nullable) — Why the requesting user has access to this resource. 'creator' = caller is the owner. 'explicit' = caller (or one of their workspace groups) is listed in role_to_group_ids beyond the workspace-wide everyone group. 'workspace_default' = the workspace-wide everyone group is listed in role_to_group_ids (every non-anon workspace member, including admins, sees this resource). 'workspace_admin' = caller is a workspace admin and the admin seat is the only path to access; reserved for docs nobody else can see. Lets the UI disclose why an admin-bypass viewer sees a doc that wasn't explicitly shared with them.
  • Allowed values: creator, explicit, workspace_admin, workspace_default

• avg_latency_secs (double, required)
• total_calls (integer, optional, default: 0) — The total number of calls to the tool

• mock_result (string, required) — The return value the LLM sees when this mock is active.
• parameter_conditions (list of UnitTestToolCallParameter, optional) — If the list is empty, the mock will always activate.
• is_error (boolean, optional, default: false) — If true, the mock result is surfaced to the LLM as a tool error rather than a successful result.

• loc (list of ValidationErrorLocItems, required)
• msg (string, required)
• type (string, required)

Configuration for extracting values from tool responses and assigning them to dynamic variables.

• dynamic_variable (string, required) — The name of the dynamic variable to assign the extracted value to
• value_path (string, required) — Dot notation path to extract the value from the source (e.g., 'user.name' or 'data.0.id')
• source ("response", optional, default: response) — The source to extract the value from. Currently only 'response' is supported.
• sanitize (boolean, optional, default: false) — If true, this assignment's value will be removed from the tool response before sending to the LLM and transcript, but still processed for variable assignment.
• preserve_native_type (boolean, optional, default: false) — If true, non-scalar values (lists, objects) extracted from the tool response are stored as their native type instead of being stringified to JSON. Enable this to use extracted arrays directly as list dynamic variables.

• dynamic_variable_placeholders (map from string to any, optional) — A dictionary of dynamic variable placeholders and their values

• description (string, optional, default: )
• dynamic_variable (string, optional, default: ) — When set, the entire parameter is populated from this dynamic variable at runtime. Mutually exclusive with description (LLM-provided value), constant_value, and is_omitted.
• constant_value (map from string to any, optional, nullable) — When set, the entire object uses this constant JSON value at runtime. Mutually exclusive with description (LLM-provided object), dynamic_variable, and is_omitted.
• is_omitted (boolean, optional, default: false) — If true, this parameter will be completely omitted from the request. Only valid for optional parameters. Mutually exclusive with description, dynamic_variable, and constant_value.
• type ("object", optional, default: object)
• required (list of string, optional)
• properties (map from string to ObjectJsonSchemaPropertyOutput, optional)
• required_constraints (RequiredConstraints, optional, nullable) — Wrapper for anyOf/allOf composition constraints scoped to required fields.

• system_tool_type: end_call (EndCallToolConfig)
• system_tool_type: end_procedure (EndProcedureToolConfig)
  • procedures (map from string to ToolResponseModelToolConfigDiscriminatorMappingSystemParamsDiscriminatorMappingEndProcedureProcedures, optional)
• system_tool_type: knowledge_base (KnowledgeBaseToolConfig)
  • enabled_strategies (list of enum, optional)
    • Allowed values: cat, keyword, semantic, ls
• system_tool_type: knowledge_base_rag (KnowledgeBaseRagToolConfig)
• system_tool_type: language_detection (LanguageDetectionToolConfig)
  • only_at_conversation_start (boolean, optional, default: false) — If no language switch happens in the first 2 user turns, later attempts fail and the conversation stays in the current language. If the language switches during those turns, later switching stays available. Enable to reduce the possibility of false switching.
• system_tool_type: play_keypad_touch_tone (PlayDTMFToolConfig)
  • suppress_turn_after_dtmf (boolean, optional, default: false) — If true, the agent will not generate further speech after playing DTMF tones. This prevents the agent's speech from interfering with IVR systems.
  • use_out_of_band_dtmf (boolean, optional, default: true) — Send DTMF tones as out-of-band RTP events (RFC 4733) instead of in-band audio. Only effective for SIP trunk imported numbers.
• system_tool_type: skip_turn (SkipTurnToolConfig)
• system_tool_type: start_procedure (StartProcedureToolConfig)
  • procedures (map from string to ToolResponseModelToolConfigDiscriminatorMappingSystemParamsDiscriminatorMappingStartProcedureProcedures, optional)
• system_tool_type: transfer_to_agent (TransferToAgentToolConfig)
  • transfers (list of AgentTransfer-Output, required)
• system_tool_type: transfer_to_number (TransferToNumberToolConfig)
  • transfers (list of PhoneNumberTransfer, required)
  • enable_client_message (boolean, optional, default: true) — Whether to play a message to the client while they wait for transfer. Defaults to true for backward compatibility.
• system_tool_type: voicemail_detection (VoicemailDetectionToolConfig)
  • voicemail_message (string, optional, nullable) — Optional message to leave on voicemail when detected. If not provided, the call will end immediately when voicemail is detected. Supports dynamic variables (e.g., {{system__time}}, {{system__call_duration_secs}}, {{custom_variable}}).

• url (string, required) — The URL that the webhook will be sent to. May include path parameters, e.g. https://example.com/agents/{agent_id}
• request_headers (map from string to WebhookToolApiSchemaConfigOutputRequestHeaders, optional) — Headers that should be included in the request
• method (enum, optional, default: GET) — The HTTP method to use for the webhook
  • Allowed values: GET, POST, PUT, PATCH, DELETE
• path_params_schema (map from string to LiteralJsonSchemaProperty, optional) — Schema for path parameters, if any. The keys should match the placeholders in the URL.
• query_params_schema (QueryParamsJsonSchema-Output, optional, nullable) — Schema for any query params, if any. These will be added to end of the URL as query params. Note: properties in a query param must all be literal types
• request_body_schema (ObjectJsonSchemaProperty-Output, optional, nullable) — Schema for the body parameters, if any. Used for POST/PATCH/PUT requests. The schema should be an object which will be sent as the json body
• response_body_schema (ObjectJsonSchemaProperty-Output, optional, nullable) — Schema describing the expected response body structure. For documentation only; not surfaced to the LLM.
• response_filter (ResponseFilter, optional, nullable) — Optional allow-list filter applied to the response before the LLM sees it, so large responses don't pollute the context. Defaults to the full response.
• content_type (enum, optional, default: application/json) — Content type for the request body. Only applies to POST/PUT/PATCH requests.
  • Allowed values: application/json, application/x-www-form-urlencoded
• auth_resolved_params (list of string, optional) — URL placeholders resolved from the auth connection (e.g. secrets injected via UrlSecretAuthConnection) rather than from path_params_schema.
• auth_connection (WebhookToolApiSchemaConfigOutputAuthConnection, optional, nullable) — Optional auth connection to use for authentication with this webhook

• eval (UnitTestToolCallParameterEval, required)
• path (string, required)

Wrapper for anyOf/allOf composition constraints scoped to required fields.

• any_of (list of RequiredConstraint, optional)
• all_of (list of RequiredConstraint, optional)

• condition (string, required)
• agent_id (string, optional, nullable)
• node_id (string, optional, nullable)
• delay_ms (integer, optional, default: 0)
• transfer_message (string, optional, nullable)
• enable_transferred_agent_first_message (boolean, optional, default: false)
• is_workflow_node_transfer (boolean, optional, default: false)
• preserve_client_tts_overrides (boolean, optional, default: false) — Defines whether TTS client overrides should be carried over to the transferred agent.

• transfer_destination (PhoneNumberTransferTransferDestination, required)
• condition (string, required)
• custom_sip_headers (list of PhoneNumberTransferCustomSipHeadersItems, optional) — Custom SIP headers to include when transferring the call. Each header can be either a static value or a dynamic variable reference.
• transfer_type (enum, optional, default: conference)
  • Allowed values: blind, conference, sip_refer
• sip_refer_play_dialtone (boolean, optional, default: true) — When True, a ringing tone is played on the original call leg while a SIP REFER transfer completes. The tone is carried over RTP to the SIP peer executing the REFER, so disable this if the receiving system (e.g. an SBC or contact center) should not hear it. When disabled the caller hears silence until the transfer completes. SIP REFER transfers only.
• uui (UUITransferConfig, optional, nullable) — User-to-User Information (RFC 7433) to attach to SIP REFER transfers. Carries call context such as CRM identifiers or escalation reason across the transfer boundary.
• post_dial_digits (PhoneNumberTransferPostDialDigits, optional, nullable) — DTMF digits to send after call connects (e.g., 'ww1234' for extension). Can be either a static value or a dynamic variable reference. Use 'w' for 0.5s pause. Only supported for Twilio transfers.
• phone_number (string, optional, nullable, deprecated)

Schema property for literal JSON types. IMPORTANT: Only ONE of the following fields can be set: description (LLM provides value), dynamic_variable (value from variable), is_system_provided (system provides value), constant_value (fixed value), or is_omitted (parameter is omitted). These are mutually exclusive.

• type (LiteralJsonSchemaPropertyType, required)
• description (string, optional, default: ) — The description of the property. When set, the LLM will provide the value based on this description. Mutually exclusive with dynamic_variable, is_system_provided, constant_value, and is_omitted.
• enum (list of string, optional, nullable) — List of allowed string values for string type parameters
• is_system_provided (boolean, optional, default: false) — If true, the value will be populated by the system at runtime. Used by API Integration Webhook tools for templating. Mutually exclusive with description, dynamic_variable, constant_value, and is_omitted.
• dynamic_variable (string, optional, default: ) — The name of the dynamic variable to use for this property's value. Mutually exclusive with description, is_system_provided, constant_value, and is_omitted.
• allowed_values (AllowedValues, optional, nullable) — Server-side rejection guard for an LLM-provided value: the runtime rejects any value outside the permitted set this object names, and the set is not advertised to the LLM as an enum. Only supported when the value source is description; combining it with dynamic_variable, is_system_provided, constant_value, or is_omitted is rejected.
• constant_value (LiteralJsonSchemaPropertyConstantValue, optional, nullable, default: ) — A constant value to use for this property. Mutually exclusive with description, dynamic_variable, is_system_provided, and is_omitted.
• is_omitted (boolean, optional, default: false) — If true, this parameter will be completely omitted from the request. Only valid for optional parameters. Mutually exclusive with description, dynamic_variable, is_system_provided, and constant_value.
• allowed_values_dynamic_variable (string, optional, default: , deprecated) — DEPRECATED: use allowed_values instead. When set, the LLM provides the value but the runtime rejects any value not present in the list held by this dynamic variable (must be a JSON array such as ["ws_alpha", "ws_beta"]). Use to let the LLM pick from a server-verified set (e.g. the IDs the current user is allowed to access). Requires description; mutually exclusive with dynamic_variable, is_system_provided, constant_value, and is_omitted.

• properties (map from string to LiteralJsonSchemaProperty, required)
• required (list of string, optional)

Configuration for filtering tool responses before they are visible to the agent.

• mode (enum, optional, default: all) — Controls how tool responses are filtered. 'all' returns entire response, 'allow' returns only specified paths, 'hide_all' hides the entire response.
  • Allowed values: all, allow, hide_all
• filters (list of string, optional) — Dot notation paths to include when mode is 'allow' (e.g., ['ticket.id', 'ticket.status']).
• content_type ("application/json", optional, default: application/json) — Content type for response filtering. Only 'application/json' responses are filtered.

Optional auth connection to use for authentication with this webhook

• type: anything (MatchAnythingParameterEvaluationStrategy)
• type: exact (ExactParameterEvaluationStrategy)
  • expected_value (string, required) — The exact string value that the parameter must match.
• type: llm (LLMParameterEvaluationStrategy)
  • description (string, required) — A description of the evaluation strategy to use for the test.
• type: regex (RegexParameterEvaluationStrategy)
  • pattern (string, required) — A regex pattern to match the agent's response against.

• description (string, optional, default: )
• dynamic_variable (string, optional, default: ) — When set, the entire parameter is populated from this dynamic variable at runtime. Mutually exclusive with description (LLM-provided value), constant_value, and is_omitted.
• constant_value (list of any, optional, nullable) — When set, the entire array uses this constant value at runtime. Mutually exclusive with description (LLM-provided array), dynamic_variable, and is_omitted.
• is_omitted (boolean, optional, default: false) — If true, this parameter will be completely omitted from the request. Only valid for optional parameters. Mutually exclusive with description, dynamic_variable, and constant_value.
• type ("array", optional, default: array)
• items (ArrayJsonSchemaPropertyOutputItems, optional, default: ) — Schema for array elements.

A set of fields that must all be present to satisfy this constraint.

• required (list of string, required)

• procedure_id (string, required) — Procedure ID
• version_id (string, required) — Version ID of the procedure version.

• procedure_id (string, required) — Procedure ID
• version_id (any, optional)

• type: phone (PhoneNumberTransferDestination)
  • phone_number (string, required)
• type: phone_dynamic_variable (PhoneNumberDynamicVariableTransferDestination)
  • phone_number (string, required)
• type: sip_uri (SIPUriTransferDestination)
  • sip_uri (string, required)
• type: sip_uri_dynamic_variable (SIPUriDynamicVariableTransferDestination)
  • sip_uri (string, required)

• type: dynamic (CustomSIPHeaderWithDynamicVariable)
  • key (string, required) — The SIP header name (e.g., 'X-Customer-ID')
  • value (string, required) — The dynamic variable name to resolve
• type: static (CustomSIPHeader)
  • key (string, required) — The SIP header name (e.g., 'X-Customer-ID')
  • value (string, required) — The header value

User-to-User Information envelope for SIP REFER transfers (RFC 7433). Outbound payloads are hex-encoded (the only encoding RFC 7433 defines). The protocol discriminator axis lets per-platform formats (Talkdesk, Genesys, ...) be expressed by configuration rather than scattered transfer flags. Further axes (ASCII encoding, header name, purpose/content parameters) can be added here without touching the transfer model.

• data (string, required) — UUI payload to send on SIP REFER transfers. Supports inline dynamic variables and is hex-encoded at transfer time.
• protocol_discriminator (string, optional, nullable) — Optional one-octet protocol discriminator (two hex digits, e.g. '00'). Required by platforms such as Genesys Cloud, which otherwise strip the first octet of the payload. Leave unset for platforms like Talkdesk that expect a bare hex payload.
• protocol_discriminator_mode (enum, optional, default: prefix) — How to attach protocol_discriminator. 'prefix' prepends the octet to the hex payload (User-to-User=XX\

;encoding=hex). 'pd_parameter' sends it as a separate parameter (User-to-User=\

;pd=XX;encoding=hex). Ignored when protocol_discriminator is unset.

• Allowed values: prefix, pd_parameter

DTMF digits to send after call connects (e.g., 'ww1234' for extension). Can be either a static value or a dynamic variable reference. Use 'w' for 0.5s pause. Only supported for Twilio transfers.

• type: dynamic (PostDialDigitsDynamicVariable)
  • value (string, required) — The dynamic variable name to resolve
• type: static (PostDialDigitsStatic)
  • value (string, required) — DTMF digits to send after call connects (e.g., 'ww1234' for extension)

Used to reference a secret from the agent's secret store.

• secret_id (string, required)

Used to reference a dynamic variable.

• variable_name (string, required)

Used to reference an environment variable by label.

• env_var_label (string, required)

• dynamic_variable (string, required) — Name of a dynamic variable that must resolve to a JSON array of permitted values, e.g. ["ws_alpha", "ws_beta"]. System variables work only if they resolve to a list.

A constant value to use for this property. Mutually exclusive with description, dynamic_variable, is_system_provided, and is_omitted.

Used to reference an auth connection from the workspace's auth connection store.

• auth_connection_id (string, required)

References an environment variable of type 'auth_connection' by label. At runtime, resolves to the auth connection for the current environment, falling back to the default environment.

• env_var_label (string, required)

Schema for array elements.

Response

{
  "id": "string",
  "tool_config": {
    "type": "system",
    "name": "end_call",
    "params": {
      "system_tool_type": "end_call"
    },
    "description": ""
  },
  "access_info": {
    "is_creator": true,
    "creator_name": "John Doe",
    "creator_email": "john.doe@example.com",
    "role": "admin",
    "access_source": "creator"
  },
  "usage_stats": {
    "avg_latency_secs": 1.1,
    "total_calls": 0
  },
  "response_mocks": [
    {
      "mock_result": "string",
      "parameter_conditions": [
        {
          "eval": {
            "description": "string",
            "type": "string"
          },
          "path": "string"
        }
      ],
      "is_error": false
    }
  ]
}

SDK Code

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

async function main() {
    const client = new ElevenLabsClient();
    await client.conversationalAi.tools.get("tool_id", {});
}
main();

from elevenlabs import ElevenLabs

client = ElevenLabs()

client.conversational_ai.tools.get(
    tool_id="tool_id",
)

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.elevenlabs.io/v1/convai/tools/tool_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.elevenlabs.io/v1/convai/tools/tool_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.elevenlabs.io/v1/convai/tools/tool_id")
  .asString();

<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.elevenlabs.io/v1/convai/tools/tool_id');

echo $response->getBody();

using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/convai/tools/tool_id");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/convai/tools/tool_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()