telnyx 5.166.0 → 5.167.0

data/rbi/telnyx/models/ai/anthropic/v1_messages_params.rbi

@@ -78,6 +78,46 @@ module Telnyx
           sig { params(metadata: T::Hash[Symbol, T.anything]).void }
           attr_writer :metadata
 
+          # 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::Anthropic::V1MessagesParams::Mode::OrSymbol)
+            )
+          end
+          attr_reader :mode
+
+          sig do
+            params(
+              mode: Telnyx::AI::Anthropic::V1MessagesParams::Mode::OrSymbol
+            ).void
+          end
+          attr_writer :mode
+
+          # 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::Anthropic::V1MessagesParams::Region::OrSymbol
+              )
+            )
+          end
+          attr_reader :region
+
+          sig do
+            params(
+              region: Telnyx::AI::Anthropic::V1MessagesParams::Region::OrSymbol
+            ).void
+          end
+          attr_writer :region
+
           # The service tier to use for this request. Supported values vary by model; use
           # the Telnyx models endpoint and inspect the model's `service_tiers` field. If
           # omitted, Telnyx-hosted models use `default`.
@@ -181,6 +221,8 @@ module Telnyx
               max_retries: Integer,
               mcp_servers: T::Array[T::Hash[Symbol, T.anything]],
               metadata: T::Hash[Symbol, T.anything],
+              mode: Telnyx::AI::Anthropic::V1MessagesParams::Mode::OrSymbol,
+              region: Telnyx::AI::Anthropic::V1MessagesParams::Region::OrSymbol,
               service_tier: String,
               stop_sequences: T::Array[String],
               stream: T::Boolean,
@@ -221,6 +263,18 @@ module Telnyx
             mcp_servers: nil,
             # An object describing metadata about the request.
             metadata: 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,
+            # 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
             # the Telnyx models endpoint and inspect the model's `service_tiers` field. If
             # omitted, Telnyx-hosted models use `default`.
@@ -264,6 +318,9 @@ module Telnyx
                 max_retries: Integer,
                 mcp_servers: T::Array[T::Hash[Symbol, T.anything]],
                 metadata: T::Hash[Symbol, T.anything],
+                mode: Telnyx::AI::Anthropic::V1MessagesParams::Mode::OrSymbol,
+                region:
+                  Telnyx::AI::Anthropic::V1MessagesParams::Region::OrSymbol,
                 service_tier: String,
                 stop_sequences: T::Array[String],
                 stream: T::Boolean,
@@ -283,6 +340,88 @@ 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::Anthropic::V1MessagesParams::Mode)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            PREFERRED =
+              T.let(
+                :preferred,
+                Telnyx::AI::Anthropic::V1MessagesParams::Mode::TaggedSymbol
+              )
+            STRICT =
+              T.let(
+                :strict,
+                Telnyx::AI::Anthropic::V1MessagesParams::Mode::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::AI::Anthropic::V1MessagesParams::Mode::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            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::Anthropic::V1MessagesParams::Region)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            USA =
+              T.let(
+                :USA,
+                Telnyx::AI::Anthropic::V1MessagesParams::Region::TaggedSymbol
+              )
+            EU =
+              T.let(
+                :EU,
+                Telnyx::AI::Anthropic::V1MessagesParams::Region::TaggedSymbol
+              )
+            AUS =
+              T.let(
+                :AUS,
+                Telnyx::AI::Anthropic::V1MessagesParams::Region::TaggedSymbol
+              )
+            UAE =
+              T.let(
+                :UAE,
+                Telnyx::AI::Anthropic::V1MessagesParams::Region::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::AI::Anthropic::V1MessagesParams::Region::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
           # System prompt. Can be a string or an array of content blocks following the
           # Anthropic API format.
           module System

data/rbi/telnyx/models/ai/chat_completion_request.rbi

@@ -110,6 +110,21 @@ module Telnyx
         sig { params(min_p: Float).void }
         attr_writer :min_p
 
+        # 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::ChatCompletionRequest::Mode::OrSymbol))
+        end
+        attr_reader :mode
+
+        sig do
+          params(mode: Telnyx::AI::ChatCompletionRequest::Mode::OrSymbol).void
+        end
+        attr_writer :mode
+
         # The language model to chat with.
         sig { returns(T.nilable(String)) }
         attr_reader :model
@@ -153,6 +168,25 @@ module Telnyx
         end
         attr_writer :reasoning_effort
 
+        # 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::ChatCompletionRequest::Region::OrSymbol)
+          )
+        end
+        attr_reader :region
+
+        sig do
+          params(
+            region: Telnyx::AI::ChatCompletionRequest::Region::OrSymbol
+          ).void
+        end
+        attr_writer :region
+
         # Use this is you want to guarantee a JSON output without defining a schema. For
         # control over the schema, use `guided_json`.
         sig do
@@ -302,11 +336,13 @@ module Telnyx
             logprobs: T::Boolean,
             max_tokens: Integer,
             min_p: Float,
+            mode: Telnyx::AI::ChatCompletionRequest::Mode::OrSymbol,
             model: String,
             n: Float,
             presence_penalty: Float,
             reasoning_effort:
               Telnyx::AI::ChatCompletionRequest::ReasoningEffort::OrSymbol,
+            region: Telnyx::AI::ChatCompletionRequest::Region::OrSymbol,
             response_format:
               Telnyx::AI::ChatCompletionRequest::ResponseFormat::OrHash,
             seed: Integer,
@@ -368,6 +404,12 @@ module Telnyx
           # [many prefer](https://github.com/huggingface/transformers/issues/27670). Must be
           # in [0, 1].
           min_p: 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,
           # The language model to chat with.
           model: nil,
           # This will return multiple choices for you instead of a single chat completion.
@@ -380,6 +422,12 @@ module Telnyx
           # all models support all values; unsupported values are rejected with a 400 error.
           # When omitted, reasoning models use their default effort level.
           reasoning_effort: 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,
           # Use this is you want to guarantee a JSON output without defining a schema. For
           # control over the schema, use `guided_json`.
           response_format: nil,
@@ -437,11 +485,13 @@ module Telnyx
               logprobs: T::Boolean,
               max_tokens: Integer,
               min_p: Float,
+              mode: Telnyx::AI::ChatCompletionRequest::Mode::OrSymbol,
               model: String,
               n: Float,
               presence_penalty: Float,
               reasoning_effort:
                 Telnyx::AI::ChatCompletionRequest::ReasoningEffort::OrSymbol,
+              region: Telnyx::AI::ChatCompletionRequest::Region::OrSymbol,
               response_format:
                 Telnyx::AI::ChatCompletionRequest::ResponseFormat,
               seed: Integer,
@@ -671,6 +721,40 @@ module Telnyx
           end
         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::ChatCompletionRequest::Mode)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PREFERRED =
+            T.let(
+              :preferred,
+              Telnyx::AI::ChatCompletionRequest::Mode::TaggedSymbol
+            )
+          STRICT =
+            T.let(
+              :strict,
+              Telnyx::AI::ChatCompletionRequest::Mode::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Telnyx::AI::ChatCompletionRequest::Mode::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+
         # Controls the reasoning effort for models that support it. When set, the model
         # spends more or less compute on internal reasoning before generating its
         # response. Supported values: none, minimal, low, medium, high, xhigh, max. Not
@@ -732,6 +816,38 @@ module Telnyx
           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::ChatCompletionRequest::Region)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          USA =
+            T.let(:USA, Telnyx::AI::ChatCompletionRequest::Region::TaggedSymbol)
+          EU =
+            T.let(:EU, Telnyx::AI::ChatCompletionRequest::Region::TaggedSymbol)
+          AUS =
+            T.let(:AUS, Telnyx::AI::ChatCompletionRequest::Region::TaggedSymbol)
+          UAE =
+            T.let(:UAE, Telnyx::AI::ChatCompletionRequest::Region::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Telnyx::AI::ChatCompletionRequest::Region::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+
         class ResponseFormat < Telnyx::Internal::Type::BaseModel
           OrHash =
             T.type_alias do

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