telnyx 5.162.0 → 5.164.0

data/rbi/telnyx/models/ai/speak_node_req.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class SpeakNodeReq < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::SpeakNodeReq, Telnyx::Internal::AnyHash)
+          end
+
+        # Caller-supplied unique identifier for this node within the flow.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Message delivered to the user verbatim when the flow reaches this node. No LLM
+        # turn — the text is spoken/sent exactly as written. `{{variable}}` placeholders
+        # are interpolated from the conversation's dynamic variables; an unresolved
+        # placeholder renders as an empty string. After delivering, the flow routes via
+        # the node's outgoing `llm` / `expression` edges (commonly a single unconditional
+        # edge).
+        sig { returns(String) }
+        attr_accessor :message
+
+        # Optional human-readable label, displayed in authoring UIs.
+        sig { returns(T.nilable(String)) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        attr_writer :name
+
+        # Optional canvas coordinates used by authoring UIs to lay out the graph. Ignored
+        # by the runtime; round-trips so frontends can persist graph layout across
+        # reloads.
+        sig { returns(T.nilable(Telnyx::AI::NodePosition)) }
+        attr_reader :position
+
+        sig { params(position: Telnyx::AI::NodePosition::OrHash).void }
+        attr_writer :position
+
+        # Node kind discriminator. Always `speak` for a speak node.
+        sig { returns(T.nilable(Telnyx::AI::SpeakNodeReq::Type::OrSymbol)) }
+        attr_reader :type
+
+        sig { params(type: Telnyx::AI::SpeakNodeReq::Type::OrSymbol).void }
+        attr_writer :type
+
+        # A standalone scripted-message step in a flow, as supplied by clients.
+        #
+        # Unlike a prompt node, a speak node has no instructions or model — it isn't an
+        # LLM turn. Reaching it delivers `message` to the user verbatim (with
+        # `{{variable}}` interpolation), then routes via outgoing `llm` / `expression`
+        # edges.
+        sig do
+          params(
+            id: String,
+            message: String,
+            name: String,
+            position: Telnyx::AI::NodePosition::OrHash,
+            type: Telnyx::AI::SpeakNodeReq::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Caller-supplied unique identifier for this node within the flow.
+          id:,
+          # Message delivered to the user verbatim when the flow reaches this node. No LLM
+          # turn — the text is spoken/sent exactly as written. `{{variable}}` placeholders
+          # are interpolated from the conversation's dynamic variables; an unresolved
+          # placeholder renders as an empty string. After delivering, the flow routes via
+          # the node's outgoing `llm` / `expression` edges (commonly a single unconditional
+          # edge).
+          message:,
+          # Optional human-readable label, displayed in authoring UIs.
+          name: nil,
+          # Optional canvas coordinates used by authoring UIs to lay out the graph. Ignored
+          # by the runtime; round-trips so frontends can persist graph layout across
+          # reloads.
+          position: nil,
+          # Node kind discriminator. Always `speak` for a speak node.
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              message: String,
+              name: String,
+              position: Telnyx::AI::NodePosition,
+              type: Telnyx::AI::SpeakNodeReq::Type::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Node kind discriminator. Always `speak` for a speak node.
+        module Type
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Telnyx::AI::SpeakNodeReq::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          SPEAK = T.let(:speak, Telnyx::AI::SpeakNodeReq::Type::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Telnyx::AI::SpeakNodeReq::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/telephony_settings.rbi

@@ -74,6 +74,20 @@ module Telnyx
         end
         attr_writer :recording_settings
 
+        # Whether the assistant sends a `call.ai_gather.message_history_updated` webhook
+        # with the full message history every time the conversation history changes. Leave
+        # unset to inherit the `send_message_history_updates` value from the
+        # `ai_assistant_start` or `gather_using_ai` command that started the conversation.
+        # Setting it here is authoritative: `true` turns the webhooks on even when the
+        # start command did not request them, and `false` turns them off even when it did.
+        # Messages exchanged during a private warm transfer acceptance phase are never
+        # included.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :send_message_history_updates
+
+        sig { params(send_message_history_updates: T::Boolean).void }
+        attr_writer :send_message_history_updates
+
         # When enabled, allows users to interact with your AI assistant directly from your
         # website without requiring authentication. This is required for FE widgets that
         # work with assistants that have telephony enabled.
@@ -141,6 +155,7 @@ module Telnyx
               Telnyx::AI::TelephonySettings::NoiseSuppressionConfig::OrHash,
             recording_settings:
               Telnyx::AI::TelephonySettings::RecordingSettings::OrHash,
+            send_message_history_updates: T::Boolean,
             supports_unauthenticated_web_calls: T::Boolean,
             time_limit_secs: Integer,
             user_idle_reply_secs: Integer,
@@ -165,6 +180,15 @@ module Telnyx
           noise_suppression_config: nil,
           # Configuration for call recording format and channel settings.
           recording_settings: nil,
+          # Whether the assistant sends a `call.ai_gather.message_history_updated` webhook
+          # with the full message history every time the conversation history changes. Leave
+          # unset to inherit the `send_message_history_updates` value from the
+          # `ai_assistant_start` or `gather_using_ai` command that started the conversation.
+          # Setting it here is authoritative: `true` turns the webhooks on even when the
+          # start command did not request them, and `false` turns them off even when it did.
+          # Messages exchanged during a private warm transfer acceptance phase are never
+          # included.
+          send_message_history_updates: nil,
           # When enabled, allows users to interact with your AI assistant directly from your
           # website without requiring authentication. This is required for FE widgets that
           # work with assistants that have telephony enabled.
@@ -204,6 +228,7 @@ module Telnyx
                 Telnyx::AI::TelephonySettings::NoiseSuppressionConfig,
               recording_settings:
                 Telnyx::AI::TelephonySettings::RecordingSettings,
+              send_message_history_updates: T::Boolean,
               supports_unauthenticated_web_calls: T::Boolean,
               time_limit_secs: Integer,
               user_idle_reply_secs: Integer,

data/rbi/telnyx/models/ai/tool_create_params.rbi

@@ -78,6 +78,12 @@ module Telnyx
         sig { params(webhook: T::Hash[Symbol, T.anything]).void }
         attr_writer :webhook
 
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_key
+
+        sig { params(idempotency_key: String).void }
+        attr_writer :idempotency_key
+
         sig do
           params(
             display_name: String,
@@ -92,6 +98,7 @@ module Telnyx
             update_dynamic_variables:
               Telnyx::AI::UpdateDynamicVariablesToolParams::OrHash,
             webhook: T::Hash[Symbol, T.anything],
+            idempotency_key: String,
             request_options: Telnyx::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
@@ -108,6 +115,7 @@ module Telnyx
           # Configuration for an update_dynamic_variables tool.
           update_dynamic_variables: nil,
           webhook: nil,
+          idempotency_key: nil,
           request_options: {}
         )
         end
@@ -127,6 +135,7 @@ module Telnyx
               update_dynamic_variables:
                 Telnyx::AI::UpdateDynamicVariablesToolParams,
               webhook: T::Hash[Symbol, T.anything],
+              idempotency_key: String,
               request_options: Telnyx::RequestOptions
             }
           )

data/rbi/telnyx/models/ai/tool_node.rbi

@@ -0,0 +1,167 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolNode < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::ToolNode, Telnyx::Internal::AnyHash)
+          end
+
+        # Caller-supplied unique identifier for this node within the flow.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # 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.
+        sig { returns(String) }
+        attr_accessor :shared_tool_id
+
+        # Optional human-readable label, displayed in authoring UIs.
+        sig { returns(T.nilable(String)) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        attr_writer :name
+
+        # Optional canvas coordinates used by authoring UIs to lay out the graph. Ignored
+        # by the runtime; round-trips so frontends can persist graph layout across
+        # reloads.
+        sig { returns(T.nilable(Telnyx::AI::NodePosition)) }
+        attr_reader :position
+
+        sig { params(position: Telnyx::AI::NodePosition::OrHash).void }
+        attr_writer :position
+
+        # Full tool definition resolved from `shared_tool_id` server-side. Populated on
+        # responses so clients can render the node without a follow-up fetch. Ignored on
+        # input — set `shared_tool_id`.
+        sig do
+          returns(T.nilable(T::Array[Telnyx::AI::AssistantTool::Variants]))
+        end
+        attr_reader :tool
+
+        sig do
+          params(
+            tool:
+              T::Array[
+                T.any(
+                  Telnyx::AI::InferenceEmbeddingWebhookToolParams::OrHash,
+                  Telnyx::AI::AssistantTool::ClientSideTool::OrHash,
+                  Telnyx::AI::RetrievalTool::OrHash,
+                  Telnyx::AI::AssistantTool::Handoff::OrHash,
+                  Telnyx::AI::HangupTool::OrHash,
+                  Telnyx::AI::AssistantTool::Transfer::OrHash,
+                  Telnyx::AI::AssistantTool::Invite::OrHash,
+                  Telnyx::AI::AssistantTool::Refer::OrHash,
+                  Telnyx::AI::AssistantTool::SendDtmf::OrHash,
+                  Telnyx::AI::AssistantTool::SendMessage::OrHash,
+                  Telnyx::AI::AssistantTool::SkipTurn::OrHash,
+                  Telnyx::AI::AssistantTool::Pay::OrHash,
+                  Telnyx::AI::AssistantTool::UpdateDynamicVariables::OrHash
+                )
+              ]
+          ).void
+        end
+        attr_writer :tool
+
+        # Node kind discriminator. Always `tool` for a tool node.
+        sig { returns(T.nilable(Telnyx::AI::ToolNode::Type::TaggedSymbol)) }
+        attr_reader :type
+
+        sig { params(type: Telnyx::AI::ToolNode::Type::OrSymbol).void }
+        attr_writer :type
+
+        # A standalone tool step in a conversation flow, as returned by the API.
+        sig do
+          params(
+            id: String,
+            shared_tool_id: String,
+            name: String,
+            position: Telnyx::AI::NodePosition::OrHash,
+            tool:
+              T::Array[
+                T.any(
+                  Telnyx::AI::InferenceEmbeddingWebhookToolParams::OrHash,
+                  Telnyx::AI::AssistantTool::ClientSideTool::OrHash,
+                  Telnyx::AI::RetrievalTool::OrHash,
+                  Telnyx::AI::AssistantTool::Handoff::OrHash,
+                  Telnyx::AI::HangupTool::OrHash,
+                  Telnyx::AI::AssistantTool::Transfer::OrHash,
+                  Telnyx::AI::AssistantTool::Invite::OrHash,
+                  Telnyx::AI::AssistantTool::Refer::OrHash,
+                  Telnyx::AI::AssistantTool::SendDtmf::OrHash,
+                  Telnyx::AI::AssistantTool::SendMessage::OrHash,
+                  Telnyx::AI::AssistantTool::SkipTurn::OrHash,
+                  Telnyx::AI::AssistantTool::Pay::OrHash,
+                  Telnyx::AI::AssistantTool::UpdateDynamicVariables::OrHash
+                )
+              ],
+            type: Telnyx::AI::ToolNode::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Caller-supplied unique identifier for this node within the flow.
+          id:,
+          # 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.
+          shared_tool_id:,
+          # Optional human-readable label, displayed in authoring UIs.
+          name: nil,
+          # Optional canvas coordinates used by authoring UIs to lay out the graph. Ignored
+          # by the runtime; round-trips so frontends can persist graph layout across
+          # reloads.
+          position: nil,
+          # Full tool definition resolved from `shared_tool_id` server-side. Populated on
+          # responses so clients can render the node without a follow-up fetch. Ignored on
+          # input — set `shared_tool_id`.
+          tool: nil,
+          # Node kind discriminator. Always `tool` for a tool node.
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              shared_tool_id: String,
+              name: String,
+              position: Telnyx::AI::NodePosition,
+              tool: T::Array[Telnyx::AI::AssistantTool::Variants],
+              type: Telnyx::AI::ToolNode::Type::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Node kind discriminator. Always `tool` for a tool node.
+        module Type
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Telnyx::AI::ToolNode::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL = T.let(:tool, Telnyx::AI::ToolNode::Type::TaggedSymbol)
+
+          sig do
+            override.returns(T::Array[Telnyx::AI::ToolNode::Type::TaggedSymbol])
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_node_req.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolNodeReq < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::ToolNodeReq, Telnyx::Internal::AnyHash)
+          end
+
+        # Caller-supplied unique identifier for this node within the flow.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # 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.
+        sig { returns(String) }
+        attr_accessor :shared_tool_id
+
+        # Optional human-readable label, displayed in authoring UIs.
+        sig { returns(T.nilable(String)) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        attr_writer :name
+
+        # Optional canvas coordinates used by authoring UIs to lay out the graph. Ignored
+        # by the runtime; round-trips so frontends can persist graph layout across
+        # reloads.
+        sig { returns(T.nilable(Telnyx::AI::NodePosition)) }
+        attr_reader :position
+
+        sig { params(position: Telnyx::AI::NodePosition::OrHash).void }
+        attr_writer :position
+
+        # Node kind discriminator. Always `tool` for a tool node.
+        sig { returns(T.nilable(Telnyx::AI::ToolNodeReq::Type::OrSymbol)) }
+        attr_reader :type
+
+        sig { params(type: Telnyx::AI::ToolNodeReq::Type::OrSymbol).void }
+        attr_writer :type
+
+        # A standalone tool step in a conversation flow, as supplied by clients.
+        #
+        # 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.
+        sig do
+          params(
+            id: String,
+            shared_tool_id: String,
+            name: String,
+            position: Telnyx::AI::NodePosition::OrHash,
+            type: Telnyx::AI::ToolNodeReq::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Caller-supplied unique identifier for this node within the flow.
+          id:,
+          # 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.
+          shared_tool_id:,
+          # Optional human-readable label, displayed in authoring UIs.
+          name: nil,
+          # Optional canvas coordinates used by authoring UIs to lay out the graph. Ignored
+          # by the runtime; round-trips so frontends can persist graph layout across
+          # reloads.
+          position: nil,
+          # Node kind discriminator. Always `tool` for a tool node.
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              shared_tool_id: String,
+              name: String,
+              position: Telnyx::AI::NodePosition,
+              type: Telnyx::AI::ToolNodeReq::Type::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Node kind discriminator. Always `tool` for a tool node.
+        module Type
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Telnyx::AI::ToolNodeReq::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL = T.let(:tool, Telnyx::AI::ToolNodeReq::Type::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Telnyx::AI::ToolNodeReq::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/transcription_settings.rbi

@@ -29,7 +29,9 @@ module Telnyx
         # does not fall back to `auto` when `language` is omitted — omitting it applies
         # `en` instead. For `reson8/turns`, supported values are `auto` (or unset) for
         # automatic language detection, and the language codes `nl`, `en`, `fr`, `fy`,
-        # `de`, `it`, `pl`, `pt`, `es`, and `sv` to fix the transcription language.
+        # `de`, `it`, `pl`, `pt`, `es`, and `sv` to fix the transcription language. For
+        # `cohere/ar-stt`, supported values are `ar` and `en`; unlike other models, this
+        # model does not auto-detect and defaults to `ar` when `language` is omitted.
         sig { returns(T.nilable(String)) }
         attr_reader :language
 
@@ -54,6 +56,7 @@ module Telnyx
         #   code-switching support.
         # - `reson8/turns` is a turn-based streaming model covering 10 European languages
         #   with automatic language detection.
+        # - `cohere/ar-stt` is a non-streaming Arabic and English transcription model.
         sig do
           returns(T.nilable(Telnyx::AI::TranscriptionSettings::Model::OrSymbol))
         end
@@ -105,7 +108,9 @@ module Telnyx
           # does not fall back to `auto` when `language` is omitted — omitting it applies
           # `en` instead. For `reson8/turns`, supported values are `auto` (or unset) for
           # automatic language detection, and the language codes `nl`, `en`, `fr`, `fy`,
-          # `de`, `it`, `pl`, `pt`, `es`, and `sv` to fix the transcription language.
+          # `de`, `it`, `pl`, `pt`, `es`, and `sv` to fix the transcription language. For
+          # `cohere/ar-stt`, supported values are `ar` and `en`; unlike other models, this
+          # model does not auto-detect and defaults to `ar` when `language` is omitted.
           language: nil,
           # The speech to text model to be used by the voice assistant. All Deepgram models
           # are run on-premise.
@@ -125,6 +130,7 @@ module Telnyx
           #   code-switching support.
           # - `reson8/turns` is a turn-based streaming model covering 10 European languages
           #   with automatic language detection.
+          # - `cohere/ar-stt` is a non-streaming Arabic and English transcription model.
           model: nil,
           # Region on third party cloud providers (currently Azure) if using one of their
           # models. Some regions require `api_key_ref`.
@@ -165,6 +171,7 @@ module Telnyx
         #   code-switching support.
         # - `reson8/turns` is a turn-based streaming model covering 10 European languages
         #   with automatic language detection.
+        # - `cohere/ar-stt` is a non-streaming Arabic and English transcription model.
         module Model
           extend Telnyx::Internal::Type::Enum
 
@@ -224,6 +231,11 @@ module Telnyx
               :"reson8/turns",
               Telnyx::AI::TranscriptionSettings::Model::TaggedSymbol
             )
+          COHERE_AR_STT =
+            T.let(
+              :"cohere/ar-stt",
+              Telnyx::AI::TranscriptionSettings::Model::TaggedSymbol
+            )
           DISTIL_WHISPER_DISTIL_LARGE_V2 =
             T.let(
               :"distil-whisper/distil-large-v2",