telnyx 5.166.0 → 5.168.0

data/rbi/telnyx/models/x402/credit_account/payment_retrieve_response.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module X402
+      module CreditAccount
+        class PaymentRetrieveResponse < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::X402::CreditAccount::PaymentRetrieveResponse,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # An x402 payment transaction.
+          sig do
+            returns(
+              T.nilable(Telnyx::X402::CreditAccount::X402TransactionRecord)
+            )
+          end
+          attr_reader :data
+
+          sig do
+            params(
+              data: Telnyx::X402::CreditAccount::X402TransactionRecord::OrHash
+            ).void
+          end
+          attr_writer :data
+
+          sig do
+            params(
+              data: Telnyx::X402::CreditAccount::X402TransactionRecord::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # An x402 payment transaction.
+            data: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              { data: Telnyx::X402::CreditAccount::X402TransactionRecord }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/x402/credit_account/x402_transaction_record.rbi

@@ -0,0 +1,219 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module X402
+      module CreditAccount
+        class X402TransactionRecord < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::X402::CreditAccount::X402TransactionRecord,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # Unique transaction identifier.
+          sig { returns(T.nilable(String)) }
+          attr_reader :id
+
+          sig { params(id: String).void }
+          attr_writer :id
+
+          # The transaction amount in the specified currency.
+          sig { returns(T.nilable(String)) }
+          attr_reader :amount
+
+          sig { params(amount: String).void }
+          attr_writer :amount
+
+          # ISO 8601 timestamp when the transaction was created.
+          sig { returns(T.nilable(Time)) }
+          attr_reader :created_at
+
+          sig { params(created_at: Time).void }
+          attr_writer :created_at
+
+          # The currency of the transaction amount (e.g. USD).
+          sig { returns(T.nilable(String)) }
+          attr_reader :currency
+
+          sig { params(currency: String).void }
+          attr_writer :currency
+
+          # The original quote ID associated with this transaction.
+          sig { returns(T.nilable(String)) }
+          attr_reader :quote_id
+
+          sig { params(quote_id: String).void }
+          attr_writer :quote_id
+
+          sig do
+            returns(
+              T.nilable(
+                Telnyx::X402::CreditAccount::X402TransactionRecord::RecordType::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :record_type
+
+          sig do
+            params(
+              record_type:
+                Telnyx::X402::CreditAccount::X402TransactionRecord::RecordType::OrSymbol
+            ).void
+          end
+          attr_writer :record_type
+
+          # The settlement status of the transaction. x402 transactions are created after
+          # successful on-chain settlement, so the status is `settled`.
+          sig do
+            returns(
+              T.nilable(
+                Telnyx::X402::CreditAccount::X402TransactionRecord::Status::TaggedSymbol
+              )
+            )
+          end
+          attr_reader :status
+
+          sig do
+            params(
+              status:
+                Telnyx::X402::CreditAccount::X402TransactionRecord::Status::OrSymbol
+            ).void
+          end
+          attr_writer :status
+
+          # The on-chain transaction hash, if available.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :tx_hash
+
+          # ISO 8601 timestamp when the transaction was last updated.
+          sig { returns(T.nilable(Time)) }
+          attr_reader :updated_at
+
+          sig { params(updated_at: Time).void }
+          attr_writer :updated_at
+
+          # An x402 payment transaction.
+          sig do
+            params(
+              id: String,
+              amount: String,
+              created_at: Time,
+              currency: String,
+              quote_id: String,
+              record_type:
+                Telnyx::X402::CreditAccount::X402TransactionRecord::RecordType::OrSymbol,
+              status:
+                Telnyx::X402::CreditAccount::X402TransactionRecord::Status::OrSymbol,
+              tx_hash: T.nilable(String),
+              updated_at: Time
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Unique transaction identifier.
+            id: nil,
+            # The transaction amount in the specified currency.
+            amount: nil,
+            # ISO 8601 timestamp when the transaction was created.
+            created_at: nil,
+            # The currency of the transaction amount (e.g. USD).
+            currency: nil,
+            # The original quote ID associated with this transaction.
+            quote_id: nil,
+            record_type: nil,
+            # The settlement status of the transaction. x402 transactions are created after
+            # successful on-chain settlement, so the status is `settled`.
+            status: nil,
+            # The on-chain transaction hash, if available.
+            tx_hash: nil,
+            # ISO 8601 timestamp when the transaction was last updated.
+            updated_at: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                amount: String,
+                created_at: Time,
+                currency: String,
+                quote_id: String,
+                record_type:
+                  Telnyx::X402::CreditAccount::X402TransactionRecord::RecordType::TaggedSymbol,
+                status:
+                  Telnyx::X402::CreditAccount::X402TransactionRecord::Status::TaggedSymbol,
+                tx_hash: T.nilable(String),
+                updated_at: Time
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module RecordType
+            extend Telnyx::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Telnyx::X402::CreditAccount::X402TransactionRecord::RecordType
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            X402_TRANSACTION =
+              T.let(
+                :x402_transaction,
+                Telnyx::X402::CreditAccount::X402TransactionRecord::RecordType::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::X402::CreditAccount::X402TransactionRecord::RecordType::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          # The settlement status of the transaction. x402 transactions are created after
+          # successful on-chain settlement, so the status is `settled`.
+          module Status
+            extend Telnyx::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Telnyx::X402::CreditAccount::X402TransactionRecord::Status
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            SETTLED =
+              T.let(
+                :settled,
+                Telnyx::X402::CreditAccount::X402TransactionRecord::Status::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::X402::CreditAccount::X402TransactionRecord::Status::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models.rbi

@@ -392,6 +392,8 @@ module Telnyx
 
   CommentRetrieveParams = Telnyx::Models::CommentRetrieveParams
 
+  Compute = Telnyx::Models::Compute
+
   Conference = Telnyx::Models::Conference
 
   ConferenceCreated = Telnyx::Models::ConferenceCreated
@@ -1254,6 +1256,8 @@ module Telnyx
   MessagingInboundMessagePayload =
     Telnyx::Models::MessagingInboundMessagePayload
 
+  MessagingMessagingProfile = Telnyx::Models::MessagingMessagingProfile
+
   MessagingMetricsTimeFrame = Telnyx::Models::MessagingMetricsTimeFrame
 
   MessagingNumbersBulkUpdateCreateParams =
@@ -1278,6 +1282,8 @@ module Telnyx
 
   MessagingProfileDeleteParams = Telnyx::Models::MessagingProfileDeleteParams
 
+  MessagingProfileFeatures = Telnyx::Models::MessagingProfileFeatures
+
   MessagingProfileListAlphanumericSenderIDsParams =
     Telnyx::Models::MessagingProfileListAlphanumericSenderIDsParams
 
@@ -2384,6 +2390,8 @@ module Telnyx
 
   Whatsapp = Telnyx::Models::Whatsapp
 
+  WhatsappAccountUpdate = Telnyx::Models::WhatsappAccountUpdate
+
   WhatsappContact = Telnyx::Models::WhatsappContact
 
   WhatsappInteractive = Telnyx::Models::WhatsappInteractive
@@ -2394,6 +2402,8 @@ module Telnyx
 
   WhatsappMessageContent = Telnyx::Models::WhatsappMessageContent
 
+  WhatsappMessageEcho = Telnyx::Models::WhatsappMessageEcho
+
   WhatsappMessageTemplateDeleteParams =
     Telnyx::Models::WhatsappMessageTemplateDeleteParams
 

data/rbi/telnyx/resources/ai/anthropic/v1.rbi

@@ -27,6 +27,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,
@@ -67,6 +69,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`.

data/rbi/telnyx/resources/ai/assistants/versions.rbi

@@ -32,6 +32,7 @@ module Telnyx
             params(
               version_id: String,
               assistant_id: String,
+              a2a_agents: T::Array[Telnyx::AI::AssistantA2AAgent::OrHash],
               conversation_flow: Telnyx::AI::ConversationFlowReq::OrHash,
               description: String,
               dynamic_variables: T::Hash[Symbol, T.anything],
@@ -88,6 +89,17 @@ module Telnyx
             version_id,
             # Path param: Unique identifier of the assistant.
             assistant_id:,
+            # Body param: 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. Omit this field
+            # to leave the assistant's agents unchanged; send an empty array to remove them
+            # all.
+            a2a_agents: nil,
             # Body param: Conversation flow as supplied by API clients (create / update).
             #
             # A directed graph of `FlowNodeReq` connected by `FlowEdge`s. Validation enforces

data/rbi/telnyx/resources/ai/assistants.rbi

@@ -39,6 +39,7 @@ module Telnyx
           params(
             instructions: String,
             name: String,
+            a2a_agents: T::Array[Telnyx::AI::AssistantA2AAgent::OrHash],
             conversation_flow: Telnyx::AI::ConversationFlowReq::OrHash,
             description: String,
             dynamic_variables: T::Hash[Symbol, T.anything],
@@ -94,6 +95,15 @@ module Telnyx
           instructions:,
           # Body param
           name:,
+          # Body param: 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,
           # Body param: Conversation flow as supplied by API clients (create / update).
           #
           # A directed graph of `FlowNodeReq` connected by `FlowEdge`s. Validation enforces
@@ -238,6 +248,7 @@ module Telnyx
         sig do
           params(
             assistant_id: String,
+            a2a_agents: T::Array[Telnyx::AI::AssistantA2AAgent::OrHash],
             conversation_flow: Telnyx::AI::ConversationFlowReq::OrHash,
             description: String,
             dynamic_variables: T::Hash[Symbol, T.anything],
@@ -293,6 +304,16 @@ module Telnyx
         def update(
           # Unique identifier of the assistant.
           assistant_id,
+          # 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. Omit this field to
+          # leave the assistant's agents unchanged; send an empty array to remove them all.
+          a2a_agents: nil,
           # Conversation flow as supplied by API clients (create / update).
           #
           # A directed graph of `FlowNodeReq` connected by `FlowEdge`s. Validation enforces

data/rbi/telnyx/resources/ai/openai/chat.rbi

@@ -18,20 +18,23 @@ module Telnyx
               early_stopping: T::Boolean,
               enable_thinking: T::Boolean,
               frequency_penalty: Float,
-              guided_choice: T::Array[String],
-              guided_json: T::Hash[Symbol, T.anything],
-              guided_regex: String,
               length_penalty: Float,
               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,
+                T.any(
+                  Telnyx::AI::ChatCompletionRequest::ResponseFormat::ResponseFormatText::OrHash,
+                  Telnyx::AI::ChatCompletionRequest::ResponseFormat::ResponseFormatJsonObject::OrHash,
+                  Telnyx::AI::ChatCompletionRequest::ResponseFormat::ResponseFormatJsonSchemaParam::OrHash
+                ),
               seed: Integer,
               service_tier: String,
               stop: Telnyx::AI::ChatCompletionRequest::Stop::Variants,
@@ -73,13 +76,6 @@ module Telnyx
             enable_thinking: nil,
             # Higher values will penalize the model from repeating the same output tokens.
             frequency_penalty: nil,
-            # If specified, the output will be exactly one of the choices.
-            guided_choice: nil,
-            # Must be a valid JSON schema. If specified, the output will follow the JSON
-            # schema.
-            guided_json: nil,
-            # If specified, the output will follow the regex pattern.
-            guided_regex: nil,
             # This is used with `use_beam_search` to prefer shorter or longer completions.
             length_penalty: nil,
             # Whether to return log probabilities of the output tokens or not. If true,
@@ -92,6 +88,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.
@@ -104,8 +106,16 @@ 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,
-            # Use this is you want to guarantee a JSON output without defining a schema. For
-            # control over the schema, use `guided_json`.
+            # 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,
+            # Controls the format of the model output. `json_object` guarantees valid JSON
+            # output without defining a schema; `json_schema` constrains the output to the
+            # JSON schema you supply via the `json_schema` property and is the supported way
+            # to get guaranteed structured output on Telnyx-hosted models.
             response_format: nil,
             # If specified, the system will make a best effort to sample deterministically,
             # such that repeated requests with the same `seed` and parameters should return

data/rbi/telnyx/resources/ai/openai.rbi

@@ -44,9 +44,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
@@ -64,10 +66,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`.

data/rbi/telnyx/resources/compute/funcs.rbi

@@ -0,0 +1,111 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Compute
+      class Funcs
+        # Returns logs oldest first. `type=runtime` (default) returns function
+        # stdout/stderr. `type=invocations` returns one platform-generated record per HTTP
+        # request served.
+        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(Telnyx::Models::Compute::FuncRetrieveLogsResponse::Variants)
+        end
+        def retrieve_logs(
+          # Function ID
+          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
+
+        # Returns aggregate request, latency, CPU, memory, and resource-limit metrics for
+        # a function over the requested window.
+        sig do
+          params(
+            id: String,
+            end_time: Time,
+            start_time: Time,
+            filter_edge_site: String,
+            filter_namespace: String,
+            page_number: Integer,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(
+            Telnyx::Models::Compute::FuncRetrieveMetricAggregatesResponse
+          )
+        end
+        def retrieve_metric_aggregates(
+          # Function ID
+          id,
+          # Exclusive window end, UTC ISO 8601 with milliseconds
+          end_time:,
+          # Inclusive window start, UTC ISO 8601 with milliseconds
+          start_time:,
+          # Edge site filter
+          filter_edge_site: nil,
+          # Kubernetes namespace filter
+          filter_namespace: nil,
+          page_number: nil,
+          page_size: nil,
+          request_options: {}
+        )
+        end
+
+        # Lists a function's ship history newest first, including per-ship failure stage
+        # and reason when recorded.
+        sig do
+          params(
+            id: String,
+            page_number: Integer,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::Compute::FuncRetrieveRevisionsResponse)
+        end
+        def retrieve_revisions(
+          # Function ID
+          id,
+          page_number: nil,
+          page_size: nil,
+          request_options: {}
+        )
+        end
+
+        # Returns the latest ship outcome. The stage is `none` on success, `pending` while
+        # building, or a failure stage such as `build`, `platform`, `pre_build`, `deploy`,
+        # or `security_review`. This stage-neutral customer-facing path is an alias over
+        # the same inspection resource as `build_log_inspection`.
+        sig do
+          params(
+            id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::Compute::FuncRetrieveShipInspectionResponse)
+        end
+        def retrieve_ship_inspection(
+          # Function ID
+          id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/compute.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Compute
+      sig { returns(Telnyx::Resources::Compute::Funcs) }
+      attr_reader :funcs
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/email_messages.rbi

@@ -210,7 +210,9 @@ module Telnyx
       )
       end
 
-      # Creates up to 50 email messages in a single request.
+      # Creates up to 1,000 email messages in a single request. Each message is
+      # validated and sent independently; per-message failures do not affect other
+      # messages in the batch. All responses use 207 Multi-Status.
       sig do
         params(
           messages: T::Array[Telnyx::EmailMessageBatchParams::Message::OrHash],
@@ -220,7 +222,9 @@ module Telnyx
         ).returns(Telnyx::Models::EmailMessageBatchResponse)
       end
       def batch(
-        # Body param
+        # Body param: Array of email messages to send. Up to 1,000 messages per batch
+        # request. Each message is validated and sent independently; per-message failures
+        # do not affect other messages in the batch.
         messages:,
         # Body param: Applies sandbox mode to all messages in the batch. Overrides any
         # per-message sandbox_mode in the messages array.