telnyx 5.166.0 → 5.168.0

data/rbi/telnyx/models/ai/inference_embedding.rbi

@@ -31,6 +31,24 @@ module Telnyx
         sig { returns(String) }
         attr_accessor :name
 
+        # A2A agents this assistant can delegate to. Tools are not stored here: at the
+        # start of every conversation each agent's card is fetched and one tool is derived
+        # per skill the card advertises, named `a2a_<name>_<skill_id>`. The following
+        # limits are not enforced when the assistant is saved, and anything past them is
+        # dropped when the conversation starts: 64 agents per assistant, 64 skills per
+        # card, 128 derived tools per assistant, and a 6 second budget for all card
+        # fetches combined. An agent whose card cannot be fetched costs the assistant that
+        # capability for the conversation; it does not fail the call.
+        sig { returns(T.nilable(T::Array[Telnyx::AI::AssistantA2AAgent])) }
+        attr_reader :a2a_agents
+
+        sig do
+          params(
+            a2a_agents: T::Array[Telnyx::AI::AssistantA2AAgent::OrHash]
+          ).void
+        end
+        attr_writer :a2a_agents
+
         # Conversation flow as returned by the API.
         sig { returns(T.nilable(Telnyx::AI::ConversationFlow)) }
         attr_reader :conversation_flow
@@ -332,6 +350,7 @@ module Telnyx
             instructions: String,
             model: String,
             name: String,
+            a2a_agents: T::Array[Telnyx::AI::AssistantA2AAgent::OrHash],
             conversation_flow: Telnyx::AI::ConversationFlow::OrHash,
             description: String,
             dynamic_variables: T::Hash[Symbol, T.anything],
@@ -395,6 +414,15 @@ module Telnyx
           # provided, Telnyx applies the default model.
           model:,
           name:,
+          # A2A agents this assistant can delegate to. Tools are not stored here: at the
+          # start of every conversation each agent's card is fetched and one tool is derived
+          # per skill the card advertises, named `a2a_<name>_<skill_id>`. The following
+          # limits are not enforced when the assistant is saved, and anything past them is
+          # dropped when the conversation starts: 64 agents per assistant, 64 skills per
+          # card, 128 derived tools per assistant, and a 6 second budget for all card
+          # fetches combined. An agent whose card cannot be fetched costs the assistant that
+          # capability for the conversation; it does not fail the call.
+          a2a_agents: nil,
           # Conversation flow as returned by the API.
           conversation_flow: nil,
           description: nil,
@@ -490,6 +518,7 @@ module Telnyx
               instructions: String,
               model: String,
               name: String,
+              a2a_agents: T::Array[Telnyx::AI::AssistantA2AAgent],
               conversation_flow: Telnyx::AI::ConversationFlow,
               description: String,
               dynamic_variables: T::Hash[Symbol, T.anything],

data/rbi/telnyx/models/ai/openai_create_response_params.rbi

@@ -41,6 +41,25 @@ module Telnyx
         sig { params(instructions: String).void }
         attr_writer :instructions
 
+        # How strictly `region` is applied. `preferred` (the default when `region` is set)
+        # tries that region first and falls back to another when the model cannot be
+        # served there, so a request that would have succeeded still succeeds. `strict`
+        # pins the request: it is served from that region or it fails with a 422, never
+        # redirected to another region. Requires `region`.
+        sig do
+          returns(
+            T.nilable(Telnyx::AI::OpenAICreateResponseParams::Mode::OrSymbol)
+          )
+        end
+        attr_reader :mode
+
+        sig do
+          params(
+            mode: Telnyx::AI::OpenAICreateResponseParams::Mode::OrSymbol
+          ).void
+        end
+        attr_writer :mode
+
         # Model identifier to use for the response, for example `zai-org/GLM-5.1-FP8` or
         # another model available from the Telnyx OpenAI-compatible models endpoint.
         sig { returns(T.nilable(String)) }
@@ -61,6 +80,25 @@ module Telnyx
         end
         attr_writer :reasoning
 
+        # Optional data-residency region the request should be served from, using the same
+        # vocabulary as your account's Data Locality setting. Behavior depends on `mode`.
+        # Supported for Telnyx-hosted models only: a request routed to an external
+        # provider never passes through Telnyx model routing, so a region cannot be
+        # enforced for it. Omit for today's latency-based routing.
+        sig do
+          returns(
+            T.nilable(Telnyx::AI::OpenAICreateResponseParams::Region::OrSymbol)
+          )
+        end
+        attr_reader :region
+
+        sig do
+          params(
+            region: Telnyx::AI::OpenAICreateResponseParams::Region::OrSymbol
+          ).void
+        end
+        attr_writer :region
+
         # The service tier to use for this request. Supported values vary by model; use
         # `GET /v2/ai/openai/models` and inspect the model's `service_tiers` field. If
         # omitted, Telnyx-hosted models use `default`.
@@ -83,9 +121,11 @@ module Telnyx
             conversation: String,
             input: T::Hash[Symbol, T.anything],
             instructions: String,
+            mode: Telnyx::AI::OpenAICreateResponseParams::Mode::OrSymbol,
             model: String,
             reasoning:
               Telnyx::AI::OpenAICreateResponseParams::Reasoning::OrHash,
+            region: Telnyx::AI::OpenAICreateResponseParams::Region::OrSymbol,
             service_tier: String,
             stream: T::Boolean,
             request_options: Telnyx::RequestOptions::OrHash
@@ -103,10 +143,22 @@ module Telnyx
           # `conversation`, send these on the first request that creates the thread;
           # subsequent turns can rely on the stored history.
           instructions: nil,
+          # How strictly `region` is applied. `preferred` (the default when `region` is set)
+          # tries that region first and falls back to another when the model cannot be
+          # served there, so a request that would have succeeded still succeeds. `strict`
+          # pins the request: it is served from that region or it fails with a 422, never
+          # redirected to another region. Requires `region`.
+          mode: nil,
           # Model identifier to use for the response, for example `zai-org/GLM-5.1-FP8` or
           # another model available from the Telnyx OpenAI-compatible models endpoint.
           model: nil,
           reasoning: nil,
+          # Optional data-residency region the request should be served from, using the same
+          # vocabulary as your account's Data Locality setting. Behavior depends on `mode`.
+          # Supported for Telnyx-hosted models only: a request routed to an external
+          # provider never passes through Telnyx model routing, so a region cannot be
+          # enforced for it. Omit for today's latency-based routing.
+          region: nil,
           # The service tier to use for this request. Supported values vary by model; use
           # `GET /v2/ai/openai/models` and inspect the model's `service_tiers` field. If
           # omitted, Telnyx-hosted models use `default`.
@@ -124,8 +176,10 @@ module Telnyx
               conversation: String,
               input: T::Hash[Symbol, T.anything],
               instructions: String,
+              mode: Telnyx::AI::OpenAICreateResponseParams::Mode::OrSymbol,
               model: String,
               reasoning: Telnyx::AI::OpenAICreateResponseParams::Reasoning,
+              region: Telnyx::AI::OpenAICreateResponseParams::Region::OrSymbol,
               service_tier: String,
               stream: T::Boolean,
               request_options: Telnyx::RequestOptions
@@ -135,6 +189,42 @@ module Telnyx
         def to_hash
         end
 
+        # How strictly `region` is applied. `preferred` (the default when `region` is set)
+        # tries that region first and falls back to another when the model cannot be
+        # served there, so a request that would have succeeded still succeeds. `strict`
+        # pins the request: it is served from that region or it fails with a 422, never
+        # redirected to another region. Requires `region`.
+        module Mode
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Telnyx::AI::OpenAICreateResponseParams::Mode)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PREFERRED =
+            T.let(
+              :preferred,
+              Telnyx::AI::OpenAICreateResponseParams::Mode::TaggedSymbol
+            )
+          STRICT =
+            T.let(
+              :strict,
+              Telnyx::AI::OpenAICreateResponseParams::Mode::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::AI::OpenAICreateResponseParams::Mode::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
         class Reasoning < Telnyx::Internal::Type::BaseModel
           OrHash =
             T.type_alias do
@@ -248,6 +338,52 @@ module Telnyx
             end
           end
         end
+
+        # Optional data-residency region the request should be served from, using the same
+        # vocabulary as your account's Data Locality setting. Behavior depends on `mode`.
+        # Supported for Telnyx-hosted models only: a request routed to an external
+        # provider never passes through Telnyx model routing, so a region cannot be
+        # enforced for it. Omit for today's latency-based routing.
+        module Region
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Telnyx::AI::OpenAICreateResponseParams::Region)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          USA =
+            T.let(
+              :USA,
+              Telnyx::AI::OpenAICreateResponseParams::Region::TaggedSymbol
+            )
+          EU =
+            T.let(
+              :EU,
+              Telnyx::AI::OpenAICreateResponseParams::Region::TaggedSymbol
+            )
+          AUS =
+            T.let(
+              :AUS,
+              Telnyx::AI::OpenAICreateResponseParams::Region::TaggedSymbol
+            )
+          UAE =
+            T.let(
+              :UAE,
+              Telnyx::AI::OpenAICreateResponseParams::Region::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::AI::OpenAICreateResponseParams::Region::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

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

@@ -26,6 +26,19 @@ module Telnyx
         sig { params(disable_dtmf: T::Boolean).void }
         attr_writer :disable_dtmf
 
+        # Destination number or SIP URI to transfer the caller to when the AI conversation
+        # ends abnormally, for example because of an assistant-side error, so the caller
+        # is not left in dead air. This only fires for abnormal ends: it does not fire
+        # when the conversation ends on purpose (the caller hung up, the assistant
+        # completed normally, the caller hung up after a relay handoff, or voicemail was
+        # detected), and it does not fire when the assistant already transferred or
+        # bridged the call.
+        sig { returns(T.nilable(String)) }
+        attr_reader :fallback_destination
+
+        sig { params(fallback_destination: String).void }
+        attr_writer :fallback_destination
+
         # The noise suppression engine to use. Use 'disabled' to turn off noise
         # suppression.
         sig do
@@ -149,6 +162,7 @@ module Telnyx
           params(
             default_texml_app_id: String,
             disable_dtmf: T::Boolean,
+            fallback_destination: String,
             noise_suppression:
               Telnyx::AI::TelephonySettings::NoiseSuppression::OrSymbol,
             noise_suppression_config:
@@ -172,6 +186,14 @@ module Telnyx
           # configured anywhere on the assistant — on the main tool array or on any workflow
           # node — enforced at write time.
           disable_dtmf: nil,
+          # Destination number or SIP URI to transfer the caller to when the AI conversation
+          # ends abnormally, for example because of an assistant-side error, so the caller
+          # is not left in dead air. This only fires for abnormal ends: it does not fire
+          # when the conversation ends on purpose (the caller hung up, the assistant
+          # completed normally, the caller hung up after a relay handoff, or voicemail was
+          # detected), and it does not fire when the assistant already transferred or
+          # bridged the call.
+          fallback_destination: nil,
           # The noise suppression engine to use. Use 'disabled' to turn off noise
           # suppression.
           noise_suppression: nil,
@@ -222,6 +244,7 @@ module Telnyx
             {
               default_texml_app_id: String,
               disable_dtmf: T::Boolean,
+              fallback_destination: String,
               noise_suppression:
                 Telnyx::AI::TelephonySettings::NoiseSuppression::OrSymbol,
               noise_suppression_config:

data/rbi/telnyx/models/compute/func_retrieve_logs_params.rbi

@@ -0,0 +1,130 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module Compute
+      class FuncRetrieveLogsParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Compute::FuncRetrieveLogsParams,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Return records at or before this RFC 3339 timestamp.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :end_time
+
+        sig { params(end_time: Time).void }
+        attr_writer :end_time
+
+        # Maximum records to return.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        # Return records at or after this RFC 3339 timestamp.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :start_time
+
+        sig { params(start_time: Time).void }
+        attr_writer :start_time
+
+        # Log stream to return.
+        sig do
+          returns(
+            T.nilable(Telnyx::Compute::FuncRetrieveLogsParams::Type::OrSymbol)
+          )
+        end
+        attr_reader :type
+
+        sig do
+          params(
+            type: Telnyx::Compute::FuncRetrieveLogsParams::Type::OrSymbol
+          ).void
+        end
+        attr_writer :type
+
+        sig do
+          params(
+            id: String,
+            end_time: Time,
+            limit: Integer,
+            start_time: Time,
+            type: Telnyx::Compute::FuncRetrieveLogsParams::Type::OrSymbol,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          # Return records at or before this RFC 3339 timestamp.
+          end_time: nil,
+          # Maximum records to return.
+          limit: nil,
+          # Return records at or after this RFC 3339 timestamp.
+          start_time: nil,
+          # Log stream to return.
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              end_time: Time,
+              limit: Integer,
+              start_time: Time,
+              type: Telnyx::Compute::FuncRetrieveLogsParams::Type::OrSymbol,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Log stream to return.
+        module Type
+          extend Telnyx::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Telnyx::Compute::FuncRetrieveLogsParams::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          RUNTIME =
+            T.let(
+              :runtime,
+              Telnyx::Compute::FuncRetrieveLogsParams::Type::TaggedSymbol
+            )
+          INVOCATIONS =
+            T.let(
+              :invocations,
+              Telnyx::Compute::FuncRetrieveLogsParams::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Telnyx::Compute::FuncRetrieveLogsParams::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end