telnyx 7.23.0 → 7.25.0

package/src/resources/ai/assistants/assistants.ts

@@ -18,6 +18,13 @@ import {
   RuleOutput,
   Serve,
 } from './canary-deploys';
+import * as DeletedAPI from './deleted';
+import {
+  Deleted,
+  DeletedAssistant,
+  DeletedAssistantsDefaultFlatPagination,
+  DeletedListParams,
+} from './deleted';
 import * as InstructionsAPI from './instructions';
 import { InstructionEnhanceParams, InstructionEnhanceResponse, Instructions } from './instructions';
 import * as ScheduledEventsAPI from './scheduled-events';
@@ -84,6 +91,7 @@ export class Assistants extends APIResource {
   versions: VersionsAPI.Versions = new VersionsAPI.Versions(this._client);
   tags: TagsAPI.Tags = new TagsAPI.Tags(this._client);
   instructions: InstructionsAPI.Instructions = new InstructionsAPI.Instructions(this._client);
+  deleted: DeletedAPI.Deleted = new DeletedAPI.Deleted(this._client);
 
   /**
    * Retrieve a list of all AI Assistants configured by the user.
@@ -151,6 +159,20 @@ export class Assistants extends APIResource {
   /**
    * Delete an AI Assistant by `assistant_id`.
    *
+   * By default this performs a soft delete: the assistant moves to the Recently
+   * Deleted list and stays restorable for 30 days, after which it is permanently
+   * deleted automatically. The assistant's versions and TeXML application are
+   * preserved during the retention window.
+   *
+   * Pass `hard_delete=true` to skip the retention window and permanently delete the
+   * assistant immediately. A hard delete erases the assistant and all of its
+   * versions, and deletes its TeXML application unless phone numbers are still
+   * assigned to it. It does not delete conversations, recordings, shared tools the
+   * assistant referenced, or knowledge-base embeddings.
+   *
+   * Deletion fails with `400` if other assistants reference this one through a
+   * handoff tool or a conversation-flow edge — remove those references first.
+   *
    * @example
    * ```ts
    * const assistant = await client.ai.assistants.delete(
@@ -158,8 +180,13 @@ export class Assistants extends APIResource {
    * );
    * ```
    */
-  delete(assistantID: string, options?: RequestOptions): APIPromise<AssistantDeleteResponse> {
-    return this._client.delete(path`/ai/assistants/${assistantID}`, options);
+  delete(
+    assistantID: string,
+    params: AssistantDeleteParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<AssistantDeleteResponse> {
+    const { hard_delete } = params ?? {};
+    return this._client.delete(path`/ai/assistants/${assistantID}`, { query: { hard_delete }, ...options });
   }
 
   /**
@@ -306,6 +333,70 @@ export class Assistants extends APIResource {
       ]),
     });
   }
+
+  /**
+   * Start a WhatsApp conversation with a customer from the business side. This
+   * endpoint:
+   *
+   * 1. Validates that `from` is a WhatsApp number on your account whose messaging
+   *    profile has this assistant configured
+   * 2. Creates a new `whatsapp_chat` conversation with the provided metadata
+   * 3. Asks the assistant to pick one of its approved WhatsApp templates and fill
+   *    its variables from `content`
+   * 4. Sends the template from `from` to `to`
+   * 5. Returns the conversation ID and the message ID
+   *
+   * When the customer replies, the reply is routed to the same conversation and the
+   * assistant answers within the 24-hour customer service window. The assistant
+   * needs a `whatsapp_template` tool with at least one approved template, data
+   * retention enabled and PII redaction disabled.
+   *
+   * @example
+   * ```ts
+   * const response = await client.ai.assistants.whatsapp(
+   *   'assistant_id',
+   *   {
+   *     content:
+   *       'Send the login verification code 482913 to the customer.',
+   *     from: '+13125550001',
+   *     to: '+13125550002',
+   *     conversation_metadata: { order_id: 'A1' },
+   *   },
+   * );
+   * ```
+   */
+  whatsapp(
+    assistantID: string,
+    params: AssistantWhatsappParams,
+    options?: RequestOptions,
+  ): APIPromise<AssistantWhatsappResponse> {
+    const { 'Idempotency-Key': idempotencyKey, ...body } = params;
+    return this._client.post(path`/ai/assistants/${assistantID}/chat/whatsapp`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        { ...(idempotencyKey != null ? { 'Idempotency-Key': idempotencyKey } : undefined) },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Restore a soft-deleted assistant from the Recently Deleted list.
+   *
+   * The assistant becomes fully active again with its versions and TeXML application
+   * as they were at deletion time. Restoring does not re-enable numbers or
+   * connections that were released separately after the deletion.
+   *
+   * @example
+   * ```ts
+   * const inferenceEmbedding =
+   *   await client.ai.assistants.restore('assistant_id');
+   * ```
+   */
+  restore(assistantID: string, options?: RequestOptions): APIPromise<InferenceEmbedding> {
+    return this._client.post(path`/ai/assistants/${assistantID}/restore`, options);
+  }
 }
 
 /**
@@ -806,6 +897,15 @@ export namespace AssistantTool {
          */
         to: string;
 
+        /**
+         * DTMF digits to send automatically after the transfer destination answers. Useful
+         * for reaching an extension behind an IVR (e.g. `"200"` to dial extension 200 once
+         * the called party picks up). Allowed characters: `0-9`, `A-D`, `w` (0.5s pause),
+         * `W` (1s pause), `*`, `#`. Maximum 64 characters. When omitted, no automatic DTMF
+         * is sent.
+         */
+        extension?: string;
+
         /**
          * The warm transfer message to deliver to this specific target. When set, it takes
          * precedence over the message the assistant composes from
@@ -817,6 +917,18 @@ export namespace AssistantTool {
          * The name of the target.
          */
         name?: string;
+
+        /**
+         * SIP Authentication password used for SIP challenges. Applies when `to` is a SIP
+         * URI.
+         */
+        sip_auth_password?: string;
+
+        /**
+         * SIP Authentication username used for SIP challenges. Applies when `to` is a SIP
+         * URI.
+         */
+        sip_auth_username?: string;
       }
 
       export interface CustomHeader {
@@ -1408,7 +1520,7 @@ export interface ConversationFlow {
 export interface ConversationFlowReq {
   /**
    * All nodes in the flow. Must contain `start_node_id`. Each node is a prompt node
-   * (`type: prompt`) or a tool node (`type: tool`).
+   * (`type: prompt`), a tool node (`type: tool`), or a speak node (`type: speak`).
    */
   nodes: Array<FlowNodeReq | ToolNodeReq | SpeakNodeReq>;
 
@@ -1423,6 +1535,73 @@ export interface ConversationFlowReq {
   edges?: Array<FlowEdge>;
 }
 
+/**
+ * Splits the conversation between a frontend model that talks to the caller and a
+ * backend model that does the work. On the GPT-Live route the frontend model
+ * cannot call tools at all — when it needs something done it raises a delegation
+ * and waits. On the chat completion route the frontend keeps a single `delegate`
+ * tool that returns immediately, so the conversation carries on while the backend
+ * works. Either way the backend's answer is spoken as commentary or kept as silent
+ * context, depending on `speak_results`. Beta feature.
+ */
+export interface DelegationSettings {
+  /**
+   * Whether the assistant delegates work to a backend model. Defaults to `true`: a
+   * GPT-Live assistant with delegation disabled can hold a conversation but can
+   * never look anything up or run a tool.
+   */
+  enabled?: boolean;
+
+  /**
+   * Run the backend on your own OpenAI-compatible endpoint instead of a
+   * Telnyx-hosted model. As above, a raw `api_key` here is rejected — reference an
+   * integration secret with `external_llm.llm_api_key_ref` instead.
+   */
+  external_llm?: ExternalLlm;
+
+  /**
+   * Extra instructions for the backend model, in addition to the assistant's own.
+   * Use this for the business rules the backend needs and the talking model does
+   * not.
+   */
+  instructions?: string;
+
+  /**
+   * Integration secret identifier for the backend model's API key. Required for
+   * models from providers other than Telnyx, OpenAI and Anthropic. A raw `api_key`
+   * is rejected rather than ignored, so that no plaintext credential is stored on
+   * the assistant.
+   */
+  llm_api_key_ref?: string;
+
+  /**
+   * Who answers a delegation. `telnyx` runs the backend model on Telnyx with the
+   * assistant's own tools, MCP servers and observability. `client` relays the
+   * delegation to a server you host over the WebSocket configured in
+   * `websocket_settings`: Telnyx sends a `session.delegation.created` frame and
+   * waits for your `session.delegation.completed` answer. That answer is text only,
+   * since the socket offers no tool vocabulary. If no socket is connected the
+   * delegation is refused and the assistant tells the caller it cannot look things
+   * up right now. Defaults to `telnyx`.
+   */
+  mode?: 'telnyx' | 'client';
+
+  /**
+   * The backend model that answers delegations. Must be a model available for AI
+   * Assistants. When enabling `telnyx` delegation, explicitly set this field or
+   * `external_llm.model`; a configuration without either backend model is rejected.
+   * Only applies when `mode` is `telnyx`.
+   */
+  model?: string;
+
+  /**
+   * Whether the backend's answer is spoken to the caller. When `true` the result is
+   * appended as commentary and paraphrased aloud; when `false` it is kept as silent
+   * context that informs later answers without being read out. Defaults to `true`.
+   */
+  speak_results?: boolean;
+}
+
 /**
  * If `telephony` is enabled, the assistant will be able to make and receive calls.
  * If `messaging` is enabled, the assistant will be able to send and receive
@@ -1623,9 +1802,14 @@ export interface FallbackConfigReq {
  * Directed transition from one node to a target, gated by a condition.
  *
  * The target is either another node in the same flow (`NodeTarget`) or a different
- * assistant (`AssistantTarget`). Multiple edges may share a `start_node_id`; the
- * runtime evaluates them in the order they're declared and takes the first whose
- * condition is true.
+ * assistant (`AssistantTarget`). Multiple edges may share a `start_node_id`. On
+ * calls, `expression` conditions are evaluated before the model turn and take
+ * precedence over `llm` conditions regardless of declaration order, while `llm`
+ * conditions are offered to the assistant's model as transition tools and fire
+ * when the model selects one. On chat channels, an `expression` condition that is
+ * true when the turn begins routes before the reply is generated; all conditioned
+ * edges that remain are considered together in declaration order after the reply,
+ * and the first true one wins.
  */
 export interface FlowEdge {
   /**
@@ -1653,15 +1837,22 @@ export interface FlowEdge {
 
 export namespace FlowEdge {
   /**
-   * Edge condition evaluated by the LLM from a natural-language prompt.
+   * Edge condition routed by the assistant's LLM from a natural-language prompt.
    *
-   * The model is asked to judge the prompt against conversation context and returns
-   * true/false. Use this for fuzzy intents that aren't expressible as a
-   * deterministic expression (e.g. 'user wants to escalate to a human').
+   * How the edge is decided depends on the channel. On calls, each outgoing `llm`
+   * condition is offered to the assistant's model as a transition tool alongside the
+   * assistant's tools, and the edge fires when the model selects it; the platform
+   * does not evaluate the prompt itself, and instructions that forbid or discourage
+   * tool calls can stop these edges from firing. On chat channels, the edge prompts
+   * are evaluated in a separate model call after the reply, which does not use the
+   * assistant's instructions. Use this for fuzzy intents that aren't expressible as
+   * a deterministic expression (e.g. 'user wants to escalate to a human').
    */
   export interface LlmCondition {
     /**
-     * Natural-language criterion the LLM judges as true/false.
+     * Natural-language criterion the model routes on. On calls this is offered to the
+     * model as the transition tool's description; on chat channels it is judged as a
+     * statement in the post-reply evaluation call.
      */
     prompt: string;
 
@@ -1843,7 +2034,7 @@ export interface FlowNode {
   /**
    * Per-node voice override (response form).
    */
-  voice_settings?: VoiceSettings;
+  voice_settings?: InferenceEmbeddingVoiceSettings;
 }
 
 /**
@@ -1927,7 +2118,8 @@ export interface FlowNodeReq {
 
   /**
    * Node kind discriminator. `prompt` (default) is an LLM-driven step; `tool` is a
-   * standalone tool execution (see `ToolNodeReq`).
+   * standalone tool execution and `speak` a scripted message (see `ToolNodeReq` /
+   * `SpeakNodeReq`).
    */
   type?: 'prompt';
 
@@ -1935,7 +2127,7 @@ export interface FlowNodeReq {
    * Per-node voice override. Only fields set here override the assistant-level voice
    * settings; unset fields cascade.
    */
-  voice_settings?: VoiceSettings;
+  voice_settings?: InferenceEmbeddingVoiceSettings;
 }
 
 export interface HangupTool {
@@ -2002,6 +2194,17 @@ export interface InferenceEmbedding {
    */
   conversation_flow?: ConversationFlow;
 
+  /**
+   * Splits the conversation between a frontend model that talks to the caller and a
+   * backend model that does the work. On the GPT-Live route the frontend model
+   * cannot call tools at all — when it needs something done it raises a delegation
+   * and waits. On the chat completion route the frontend keeps a single `delegate`
+   * tool that returns immediately, so the conversation carries on while the backend
+   * works. Either way the backend's answer is spoken as commentary or kept as silent
+   * context, depending on `speak_results`. Beta feature.
+   */
+  delegation_settings?: DelegationSettings;
+
   description?: string;
 
   /**
@@ -2140,7 +2343,16 @@ export interface InferenceEmbedding {
    */
   version_name?: string;
 
-  voice_settings?: VoiceSettings;
+  voice_settings?: InferenceEmbeddingVoiceSettings;
+
+  /**
+   * Streams conversation and telephony events to a WebSocket server you host, and
+   * accepts messages injected back into the conversation. Telnyx opens the
+   * connection as a client, once per conversation. Delivery is best effort
+   * throughout: while the connection is down events are dropped rather than queued,
+   * and no socket failure is ever allowed to affect the call. Beta feature.
+   */
+  websocket_settings?: WebsocketSettings;
 
   /**
    * Configuration settings for the assistant's web widget.
@@ -2182,6 +2394,185 @@ export interface InferenceEmbeddingInterruptionSettings {
   start_speaking_plan?: StartSpeakingPlan;
 }
 
+export interface InferenceEmbeddingVoiceSettings {
+  /**
+   * The voice to be used by the voice assistant. Check the full list of
+   * [available voices](https://developers.telnyx.com/docs/tts-stt/tts-available-voices)
+   * via our voices API. To use ElevenLabs, you must reference your ElevenLabs API
+   * key as an integration secret under the `api_key_ref` field. See
+   * [integration secrets documentation](https://developers.telnyx.com/api-reference/integration-secrets/create-a-secret)
+   * for details. For Telnyx voices, use `Telnyx.<model_id>.<voice_id>` (e.g.
+   * Telnyx.KokoroTTS.af_heart). For Soniox voices, use `Soniox.tts-rt-v2.<voice_id>`
+   * (e.g. Soniox.tts-rt-v2.Emma); every Soniox voice speaks all supported languages.
+   * The voice portion of the identifier supports
+   * [dynamic variables](https://developers.telnyx.com/docs/inference/ai-assistants/dynamic-variables)
+   * using mustache syntax (e.g. `Telnyx.Ultra.{{voice_id}}`). The variable is
+   * resolved at call time from your dynamic variables webhook, allowing you to
+   * select the voice dynamically per call.
+   */
+  voice: string;
+
+  /**
+   * The `identifier` for an integration secret
+   * [/v2/integration_secrets](https://developers.telnyx.com/api-reference/integration-secrets/create-a-secret)
+   * that refers to your ElevenLabs API key. Warning: Free plans are unlikely to work
+   * with this integration.
+   */
+  api_key_ref?: string;
+
+  /**
+   * Optional background audio to play on the call. Use a predefined media bed, or
+   * supply a looped MP3 URL. If a media URL is chosen in the portal, customers can
+   * preview it before saving.
+   */
+  background_audio?:
+    | InferenceEmbeddingVoiceSettings.UnionMember0
+    | InferenceEmbeddingVoiceSettings.UnionMember1
+    | InferenceEmbeddingVoiceSettings.UnionMember2;
+
+  /**
+   * Enables emotionally expressive speech using SSML emotion tags. When enabled, the
+   * assistant uses audio tags like angry, excited, content, and sad to add emotional
+   * nuance. Only supported for Telnyx Ultra voices.
+   */
+  expressive_mode?: boolean;
+
+  /**
+   * Enhances recognition for specific languages and dialects during MiniMax TTS
+   * synthesis. Default is null (no boost). Set to 'auto' for automatic language
+   * detection. Only applicable when using MiniMax voices.
+   */
+  language_boost?:
+    | 'auto'
+    | 'Chinese'
+    | 'Chinese,Yue'
+    | 'English'
+    | 'Arabic'
+    | 'Russian'
+    | 'Spanish'
+    | 'French'
+    | 'Portuguese'
+    | 'German'
+    | 'Turkish'
+    | 'Dutch'
+    | 'Ukrainian'
+    | 'Vietnamese'
+    | 'Indonesian'
+    | 'Japanese'
+    | 'Italian'
+    | 'Korean'
+    | 'Thai'
+    | 'Polish'
+    | 'Romanian'
+    | 'Greek'
+    | 'Czech'
+    | 'Finnish'
+    | 'Hindi'
+    | 'Bulgarian'
+    | 'Danish'
+    | 'Hebrew'
+    | 'Malay'
+    | 'Persian'
+    | 'Slovak'
+    | 'Swedish'
+    | 'Croatian'
+    | 'Filipino'
+    | 'Hungarian'
+    | 'Norwegian'
+    | 'Slovenian'
+    | 'Catalan'
+    | 'Nynorsk'
+    | 'Tamil'
+    | 'Afrikaans'
+    | null;
+
+  /**
+   * Determines how closely the AI should adhere to the original voice when
+   * attempting to replicate it. Only applicable when using ElevenLabs.
+   */
+  similarity_boost?: number;
+
+  /**
+   * Adjusts speech velocity. 1.0 is default speed; values less than 1.0 slow speech;
+   * values greater than 1.0 accelerate it. Only applicable when using ElevenLabs.
+   */
+  speed?: number;
+
+  /**
+   * Determines the style exaggeration of the voice. Amplifies speaker style but
+   * consumes additional resources when set above 0. Only applicable when using
+   * ElevenLabs.
+   */
+  style?: number;
+
+  /**
+   * Determines how stable the voice is and the randomness between each generation.
+   * Lower values create a broader emotional range; higher values produce more
+   * consistent, monotonous output. Only applicable when using ElevenLabs.
+   */
+  temperature?: number;
+
+  /**
+   * Amplifies similarity to the original speaker voice. Increases computational load
+   * and latency slightly. Only applicable when using ElevenLabs.
+   */
+  use_speaker_boost?: boolean;
+
+  /**
+   * The speed of the voice in the range [0.6, 1.5]. 1.0 is the default speed. Larger
+   * numbers make the voice faster, smaller numbers make it slower. Applies to Telnyx
+   * `Ultra` voices; values outside this range are rejected by the synthesis engine.
+   * Soniox voices support a speed range of 0.7 to 1.3.
+   */
+  voice_speed?: number;
+}
+
+export namespace InferenceEmbeddingVoiceSettings {
+  export interface UnionMember0 {
+    /**
+     * Select from predefined media options.
+     */
+    type: 'predefined_media';
+
+    /**
+     * The predefined media to use. `silence` disables background audio.
+     */
+    value: 'silence' | 'office';
+
+    /**
+     * Volume level for the predefined background audio. Supports values from 0.1 to
+     * 1.0 in 0.1 increments.
+     */
+    volume?: number;
+  }
+
+  export interface UnionMember1 {
+    /**
+     * Provide a direct URL to an MP3 file. The audio will loop during the call.
+     */
+    type: 'media_url';
+
+    /**
+     * HTTPS URL to an MP3 file.
+     */
+    value: string;
+  }
+
+  export interface UnionMember2 {
+    /**
+     * Reference a previously uploaded media by its name from Telnyx Media Storage.
+     */
+    type: 'media_name';
+
+    /**
+     * The `name` of a media asset created via
+     * [Media Storage API](https://developers.telnyx.com/api/media-storage/create-media-storage).
+     * The audio will loop during the call.
+     */
+    value: string;
+  }
+}
+
 export interface InferenceEmbeddingWebhookToolParams {
   type: 'webhook';
 
@@ -2197,6 +2588,14 @@ export interface InferenceEmbeddingWebhookToolParams {
    * per assistant).
    */
   shared?: boolean;
+
+  /**
+   * The maximum number of milliseconds to wait for the webhook to respond before the
+   * tool call is aborted. Set this at the tool level, as a sibling of `type` — a
+   * `timeout_ms` nested inside the `webhook` object is stored but not applied, and
+   * the tool runs at this default instead. Applies when `webhook.async` is false.
+   */
+  timeout_ms?: number;
 }
 
 export namespace InferenceEmbeddingWebhookToolParams {
@@ -2308,12 +2707,6 @@ export namespace InferenceEmbeddingWebhookToolParams {
      * dot-notation path to the value in the response body.
      */
     store_fields_as_variables?: Array<Webhook.StoreFieldsAsVariable>;
-
-    /**
-     * The maximum number of milliseconds to wait for the webhook to respond. Only
-     * applicable when async is false.
-     */
-    timeout_ms?: number;
   }
 
   export namespace Webhook {
@@ -2968,13 +3361,24 @@ export interface ToolNode {
   /**
    * ID of the single shared (org-level) tool this node executes. When the flow
    * reaches this node the tool runs as a deliberate step (no LLM turn); its outgoing
-   * `tool_result` edges then route on the outcome. Arguments are filled from the
-   * conversation's dynamic variables by name — a dynamic variable whose name matches
-   * one of the tool's parameters supplies that argument. Cross-validated against the
-   * org's shared tools on write.
+   * `llm` / `expression` edges route the flow on the tool's outcome. Arguments are
+   * filled from the conversation's dynamic variables by name — a dynamic variable
+   * whose name matches one of the tool's parameters supplies that argument.
+   * Cross-validated against the org's shared tools on write.
    */
   shared_tool_id: string;
 
+  /**
+   * Optional message delivered to the user verbatim immediately before the tool
+   * executes — an announcement such as 'One moment while I look that up.' No LLM
+   * turn and no customer turn: the message is spoken/sent, then the tool runs, in
+   * the same deterministic step. `{{variable}}` placeholders are interpolated from
+   * the conversation's dynamic variables (unresolved → empty string); the tool's own
+   * result is not yet available when the message is rendered. Omit for a silent tool
+   * step.
+   */
+  message?: string;
+
   /**
    * Optional human-readable label, displayed in authoring UIs.
    */
@@ -3005,8 +3409,10 @@ export interface ToolNode {
  *
  * Unlike a prompt node, a tool node has no instructions or model — it isn't an LLM
  * turn. Reaching it deterministically runs one shared tool (arguments filled from
- * matching dynamic variables by name), then routes on the result via outgoing
- * `tool_result` edges.
+ * matching dynamic variables by name), then routes via outgoing `llm` /
+ * `expression` edges, with exactly one `default` fallback edge required when the
+ * node has any outgoing edges (the tool's outcome is readable as
+ * `telnyx_last_tool_status_code` in `expression` conditions).
  */
 export interface ToolNodeReq {
   /**
@@ -3017,13 +3423,24 @@ export interface ToolNodeReq {
   /**
    * ID of the single shared (org-level) tool this node executes. When the flow
    * reaches this node the tool runs as a deliberate step (no LLM turn); its outgoing
-   * `tool_result` edges then route on the outcome. Arguments are filled from the
-   * conversation's dynamic variables by name — a dynamic variable whose name matches
-   * one of the tool's parameters supplies that argument. Cross-validated against the
-   * org's shared tools on write.
+   * `llm` / `expression` edges route the flow on the tool's outcome. Arguments are
+   * filled from the conversation's dynamic variables by name — a dynamic variable
+   * whose name matches one of the tool's parameters supplies that argument.
+   * Cross-validated against the org's shared tools on write.
    */
   shared_tool_id: string;
 
+  /**
+   * Optional message delivered to the user verbatim immediately before the tool
+   * executes — an announcement such as 'One moment while I look that up.' No LLM
+   * turn and no customer turn: the message is spoken/sent, then the tool runs, in
+   * the same deterministic step. `{{variable}}` placeholders are interpolated from
+   * the conversation's dynamic variables (unresolved → empty string); the tool's own
+   * result is not yet available when the message is rendered. Omit for a silent tool
+   * step.
+   */
+  message?: string;
+
   /**
    * Optional human-readable label, displayed in authoring UIs.
    */
@@ -3397,9 +3814,9 @@ export interface VoiceSettings {
   use_speaker_boost?: boolean;
 
   /**
-   * The speed of the voice in the range [0.25, 2.0]. 1.0 is deafult speed. Larger
-   * numbers make the voice faster, smaller numbers make it slower. This is only
-   * applicable for Telnyx Natural voices.
+   * The speed of the voice in the range [0.6, 1.5]. 1.0 is the default speed. Larger
+   * numbers make the voice faster, smaller numbers make it slower. Applies to Telnyx
+   * `Ultra` voices; values outside this range are rejected by the synthesis engine.
    */
   voice_speed?: number;
 }
@@ -3454,6 +3871,14 @@ export interface WebhookTool {
   type: 'webhook';
 
   webhook: WebhookTool.Webhook;
+
+  /**
+   * The maximum number of milliseconds to wait for the webhook to respond before the
+   * tool call is aborted. Set this at the tool level, as a sibling of `type` — a
+   * `timeout_ms` nested inside the `webhook` object is not applied, and the tool
+   * runs at this default instead.
+   */
+  timeout_ms?: number;
 }
 
 export namespace WebhookTool {
@@ -3590,6 +4015,35 @@ export namespace WebhookTool {
   }
 }
 
+/**
+ * Streams conversation and telephony events to a WebSocket server you host, and
+ * accepts messages injected back into the conversation. Telnyx opens the
+ * connection as a client, once per conversation. Delivery is best effort
+ * throughout: while the connection is down events are dropped rather than queued,
+ * and no socket failure is ever allowed to affect the call. Beta feature.
+ */
+export interface WebsocketSettings {
+  /**
+   * Integration secret identifier whose value Telnyx sends as an
+   * `Authorization: Bearer <value>` header on the upgrade request. Resolved on every
+   * connection attempt, so a rotated secret is picked up by the next reconnect.
+   */
+  auth_ref?: string;
+
+  /**
+   * Whether Telnyx opens a WebSocket to `url` for each of this assistant's
+   * conversations. Defaults to `false`.
+   */
+  enabled?: boolean;
+
+  /**
+   * The `ws://` or `wss://` endpoint Telnyx connects to. Required when `enabled` is
+   * `true`. Must be externally reachable — localhost, private IP ranges and `.local`
+   * domains are rejected.
+   */
+  url?: string;
+}
+
 /**
  * Configuration settings for the assistant's web widget.
  */
@@ -3672,6 +4126,18 @@ export interface AssistantSendSMSResponse {
   conversation_id?: string;
 }
 
+export interface AssistantWhatsappResponse {
+  /**
+   * ID of the conversation created for this WhatsApp chat.
+   */
+  conversation_id: string;
+
+  /**
+   * ID of the WhatsApp template message that was sent.
+   */
+  message_id: string;
+}
+
 export interface AssistantCreateParams {
   /**
    * Body param: System instructions for the assistant. These may be templated with
@@ -3705,6 +4171,17 @@ export interface AssistantCreateParams {
    */
   conversation_flow?: ConversationFlowReq;
 
+  /**
+   * Body param: Splits the conversation between a frontend model that talks to the
+   * caller and a backend model that does the work. On the GPT-Live route the
+   * frontend model cannot call tools at all — when it needs something done it raises
+   * a delegation and waits. On the chat completion route the frontend keeps a single
+   * `delegate` tool that returns immediately, so the conversation carries on while
+   * the backend works. Either way the backend's answer is spoken as commentary or
+   * kept as silent context, depending on `speak_results`. Beta feature.
+   */
+  delegation_settings?: DelegationSettings;
+
   /**
    * Body param
    */
@@ -3866,7 +4343,16 @@ export interface AssistantCreateParams {
   /**
    * Body param
    */
-  voice_settings?: VoiceSettings;
+  voice_settings?: InferenceEmbeddingVoiceSettings;
+
+  /**
+   * Body param: Streams conversation and telephony events to a WebSocket server you
+   * host, and accepts messages injected back into the conversation. Telnyx opens the
+   * connection as a client, once per conversation. Delivery is best effort
+   * throughout: while the connection is down events are dropped rather than queued,
+   * and no socket failure is ever allowed to affect the call. Beta feature.
+   */
+  websocket_settings?: WebsocketSettings;
 
   /**
    * Body param: Configuration settings for the assistant's web widget.
@@ -3918,6 +4404,14 @@ export interface AssistantImportsParams {
   'Idempotency-Key'?: string;
 }
 
+export interface AssistantDeleteParams {
+  /**
+   * Permanently delete the assistant immediately instead of soft-deleting it to the
+   * Recently Deleted list, where it stays restorable for 30 days.
+   */
+  hard_delete?: boolean;
+}
+
 export interface AssistantRetrieveParams {
   /**
    * Filter results by call control id.
@@ -3963,6 +4457,17 @@ export interface AssistantUpdateParams {
    */
   conversation_flow?: ConversationFlowReq;
 
+  /**
+   * Splits the conversation between a frontend model that talks to the caller and a
+   * backend model that does the work. On the GPT-Live route the frontend model
+   * cannot call tools at all — when it needs something done it raises a delegation
+   * and waits. On the chat completion route the frontend keeps a single `delegate`
+   * tool that returns immediately, so the conversation carries on while the backend
+   * works. Either way the backend's answer is spoken as commentary or kept as silent
+   * context, depending on `speak_results`. Beta feature.
+   */
+  delegation_settings?: DelegationSettings;
+
   description?: string;
 
   /**
@@ -4120,7 +4625,16 @@ export interface AssistantUpdateParams {
    */
   version_name?: string;
 
-  voice_settings?: VoiceSettings;
+  voice_settings?: InferenceEmbeddingVoiceSettings;
+
+  /**
+   * Streams conversation and telephony events to a WebSocket server you host, and
+   * accepts messages injected back into the conversation. Telnyx opens the
+   * connection as a client, once per conversation. Delivery is best effort
+   * throughout: while the connection is down events are dropped rather than queued,
+   * and no socket failure is ever allowed to affect the call. Beta feature.
+   */
+  websocket_settings?: WebsocketSettings;
 
   /**
    * Configuration settings for the assistant's web widget.
@@ -4207,6 +4721,44 @@ export interface AssistantSendSMSParams {
   'Idempotency-Key'?: string;
 }
 
+export interface AssistantWhatsappParams {
+  /**
+   * Body param: Instruction for the assistant, including the values for the template
+   * variables, e.g. `Send the login verification code 482913 to the customer.`
+   */
+  content: string;
+
+  /**
+   * Body param: WhatsApp number on your account to send from, in E.164 format. Its
+   * messaging profile must have this assistant configured.
+   */
+  from: string;
+
+  /**
+   * Body param: Customer to message, as an E.164 phone number or a WhatsApp
+   * business-scoped user ID (BSUID).
+   */
+  to: string;
+
+  /**
+   * Body param: Metadata stored on the conversation. Keys starting with `telnyx_`
+   * and the `assistant_id` key are reserved.
+   */
+  conversation_metadata?: { [key: string]: string | number | boolean };
+
+  /**
+   * Header param: Optional opaque, unquoted key for safely retrying the same logical
+   * request. Keys must contain 1 to 255 letters, numbers, hyphens, or underscores.
+   * Generate a unique UUID v4 for each operation and reuse it only when retrying
+   * that operation with the same request. Invalid headers—including duplicate,
+   * empty, malformed, or overlong values—return 400 with error code 10015. A request
+   * already in progress with the same key returns 409; reusing the key with a
+   * different request returns 422. Only successful responses are replayed, for up to
+   * 24 hours. Do not include sensitive data in the key.
+   */
+  'Idempotency-Key'?: string;
+}
+
 Assistants.Tests = Tests;
 Assistants.CanaryDeploys = CanaryDeploys;
 Assistants.ScheduledEvents = ScheduledEvents;
@@ -4214,6 +4766,7 @@ Assistants.Tools = Tools;
 Assistants.Versions = Versions;
 Assistants.Tags = Tags;
 Assistants.Instructions = Instructions;
+Assistants.Deleted = Deleted;
 
 export declare namespace Assistants {
   export {
@@ -4230,6 +4783,7 @@ export declare namespace Assistants {
     type ComparisonExpression as ComparisonExpression,
     type ConversationFlow as ConversationFlow,
     type ConversationFlowReq as ConversationFlowReq,
+    type DelegationSettings as DelegationSettings,
     type EnabledFeatures as EnabledFeatures,
     type Expression as Expression,
     type ExternalLlm as ExternalLlm,
@@ -4244,6 +4798,7 @@ export declare namespace Assistants {
     type ImportMetadata as ImportMetadata,
     type InferenceEmbedding as InferenceEmbedding,
     type InferenceEmbeddingInterruptionSettings as InferenceEmbeddingInterruptionSettings,
+    type InferenceEmbeddingVoiceSettings as InferenceEmbeddingVoiceSettings,
     type InferenceEmbeddingWebhookToolParams as InferenceEmbeddingWebhookToolParams,
     type InsightSettings as InsightSettings,
     type MessagingSettings as MessagingSettings,
@@ -4268,18 +4823,22 @@ export declare namespace Assistants {
     type TransferTool as TransferTool,
     type VoiceSettings as VoiceSettings,
     type WebhookTool as WebhookTool,
+    type WebsocketSettings as WebsocketSettings,
     type WidgetSettings as WidgetSettings,
     type AssistantDeleteResponse as AssistantDeleteResponse,
     type AssistantChatResponse as AssistantChatResponse,
     type AssistantGetTexmlResponse as AssistantGetTexmlResponse,
     type AssistantSendSMSResponse as AssistantSendSMSResponse,
+    type AssistantWhatsappResponse as AssistantWhatsappResponse,
     type AssistantCreateParams as AssistantCreateParams,
     type AssistantImportsParams as AssistantImportsParams,
+    type AssistantDeleteParams as AssistantDeleteParams,
     type AssistantRetrieveParams as AssistantRetrieveParams,
     type AssistantUpdateParams as AssistantUpdateParams,
     type AssistantChatParams as AssistantChatParams,
     type AssistantCloneParams as AssistantCloneParams,
     type AssistantSendSMSParams as AssistantSendSMSParams,
+    type AssistantWhatsappParams as AssistantWhatsappParams,
   };
 
   export {
@@ -4352,4 +4911,11 @@ export declare namespace Assistants {
     type InstructionEnhanceResponse as InstructionEnhanceResponse,
     type InstructionEnhanceParams as InstructionEnhanceParams,
   };
+
+  export {
+    Deleted as Deleted,
+    type DeletedAssistant as DeletedAssistant,
+    type DeletedAssistantsDefaultFlatPagination as DeletedAssistantsDefaultFlatPagination,
+    type DeletedListParams as DeletedListParams,
+  };
 }