telnyx 5.162.0 → 5.164.0

data/rbi/telnyx/models/ai/knowledge/collection_retrieve_documents_response.rbi

@@ -0,0 +1,336 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Knowledge
+        class CollectionRetrieveDocumentsResponse < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Data
+                ]
+              )
+            )
+          end
+          attr_reader :data
+
+          sig do
+            params(
+              data:
+                T::Array[
+                  Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Data::OrHash
+                ]
+            ).void
+          end
+          attr_writer :data
+
+          sig do
+            returns(
+              T.nilable(
+                Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Meta
+              )
+            )
+          end
+          attr_reader :meta
+
+          sig do
+            params(
+              meta:
+                Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Meta::OrHash
+            ).void
+          end
+          attr_writer :meta
+
+          sig do
+            params(
+              data:
+                T::Array[
+                  Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Data::OrHash
+                ],
+              meta:
+                Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Meta::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(data: nil, meta: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                data:
+                  T::Array[
+                    Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Data
+                  ],
+                meta:
+                  Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Meta
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Data < Telnyx::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Data,
+                  Telnyx::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :id
+
+            sig { params(id: String).void }
+            attr_writer :id
+
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :chunk_index
+
+            sig { params(chunk_index: Integer).void }
+            attr_writer :chunk_index
+
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :chunk_total
+
+            sig { params(chunk_total: Integer).void }
+            attr_writer :chunk_total
+
+            sig { returns(T.nilable(Time)) }
+            attr_reader :ingested_at
+
+            sig { params(ingested_at: Time).void }
+            attr_writer :ingested_at
+
+            sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+            attr_reader :metadata
+
+            sig { params(metadata: T::Hash[Symbol, T.anything]).void }
+            attr_writer :metadata
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :organization_id
+
+            sig { params(organization_id: String).void }
+            attr_writer :organization_id
+
+            sig { returns(T.nilable(Time)) }
+            attr_reader :record_created_at
+
+            sig { params(record_created_at: Time).void }
+            attr_writer :record_created_at
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :record_id
+
+            sig { params(record_id: String).void }
+            attr_writer :record_id
+
+            # The source record kind this chunk came from (e.g. `voice`, `meeting_bot`,
+            # `message`).
+            sig { returns(T.nilable(String)) }
+            attr_reader :record_type
+
+            sig { params(record_type: String).void }
+            attr_writer :record_type
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :region
+
+            sig { params(region: String).void }
+            attr_writer :region
+
+            # Relevance score (higher = more relevant) for ranked search. `0.0` for plain
+            # catalog listings (when `query` is omitted).
+            sig { returns(T.nilable(Float)) }
+            attr_reader :score
+
+            sig { params(score: Float).void }
+            attr_writer :score
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :text
+
+            sig { params(text: String).void }
+            attr_writer :text
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :user_id
+
+            sig { params(user_id: String).void }
+            attr_writer :user_id
+
+            sig do
+              params(
+                id: String,
+                chunk_index: Integer,
+                chunk_total: Integer,
+                ingested_at: Time,
+                metadata: T::Hash[Symbol, T.anything],
+                organization_id: String,
+                record_created_at: Time,
+                record_id: String,
+                record_type: String,
+                region: String,
+                score: Float,
+                text: String,
+                user_id: String
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              id: nil,
+              chunk_index: nil,
+              chunk_total: nil,
+              ingested_at: nil,
+              metadata: nil,
+              organization_id: nil,
+              record_created_at: nil,
+              record_id: nil,
+              # The source record kind this chunk came from (e.g. `voice`, `meeting_bot`,
+              # `message`).
+              record_type: nil,
+              region: nil,
+              # Relevance score (higher = more relevant) for ranked search. `0.0` for plain
+              # catalog listings (when `query` is omitted).
+              score: nil,
+              text: nil,
+              user_id: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  id: String,
+                  chunk_index: Integer,
+                  chunk_total: Integer,
+                  ingested_at: Time,
+                  metadata: T::Hash[Symbol, T.anything],
+                  organization_id: String,
+                  record_created_at: Time,
+                  record_id: String,
+                  record_type: String,
+                  region: String,
+                  score: Float,
+                  text: String,
+                  user_id: String
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+
+          class Meta < Telnyx::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Telnyx::Models::AI::Knowledge::CollectionRetrieveDocumentsResponse::Meta,
+                  Telnyx::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :collection_slug
+
+            sig { params(collection_slug: String).void }
+            attr_writer :collection_slug
+
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :page_number
+
+            sig { params(page_number: Integer).void }
+            attr_writer :page_number
+
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :page_size
+
+            sig { params(page_size: Integer).void }
+            attr_writer :page_size
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :retrieval_type
+
+            sig { params(retrieval_type: String).void }
+            attr_writer :retrieval_type
+
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_reader :searched_sources
+
+            sig { params(searched_sources: T::Array[String]).void }
+            attr_writer :searched_sources
+
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :top_k
+
+            sig { params(top_k: Integer).void }
+            attr_writer :top_k
+
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :total_pages
+
+            sig { params(total_pages: Integer).void }
+            attr_writer :total_pages
+
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :total_results
+
+            sig { params(total_results: Integer).void }
+            attr_writer :total_results
+
+            sig do
+              params(
+                collection_slug: String,
+                page_number: Integer,
+                page_size: Integer,
+                retrieval_type: String,
+                searched_sources: T::Array[String],
+                top_k: Integer,
+                total_pages: Integer,
+                total_results: Integer
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              collection_slug: nil,
+              page_number: nil,
+              page_size: nil,
+              retrieval_type: nil,
+              searched_sources: nil,
+              top_k: nil,
+              total_pages: nil,
+              total_results: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  collection_slug: String,
+                  page_number: Integer,
+                  page_size: Integer,
+                  retrieval_type: String,
+                  searched_sources: T::Array[String],
+                  top_k: Integer,
+                  total_pages: Integer,
+                  total_results: Integer
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/mcp_server_create_params.rbi

@@ -27,6 +27,12 @@ module Telnyx
         sig { returns(T.nilable(String)) }
         attr_accessor :api_key_ref
 
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_key
+
+        sig { params(idempotency_key: String).void }
+        attr_writer :idempotency_key
+
         sig do
           params(
             name: String,
@@ -34,6 +40,7 @@ module Telnyx
             url: String,
             allowed_tools: T.nilable(T::Array[String]),
             api_key_ref: T.nilable(String),
+            idempotency_key: String,
             request_options: Telnyx::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
@@ -43,6 +50,7 @@ module Telnyx
           url:,
           allowed_tools: nil,
           api_key_ref: nil,
+          idempotency_key: nil,
           request_options: {}
         )
         end
@@ -55,6 +63,7 @@ module Telnyx
               url: String,
               allowed_tools: T.nilable(T::Array[String]),
               api_key_ref: T.nilable(String),
+              idempotency_key: String,
               request_options: Telnyx::RequestOptions
             }
           )

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

@@ -49,6 +49,18 @@ module Telnyx
         sig { params(model: String).void }
         attr_writer :model
 
+        sig do
+          returns(T.nilable(Telnyx::AI::OpenAICreateResponseParams::Reasoning))
+        end
+        attr_reader :reasoning
+
+        sig do
+          params(
+            reasoning: Telnyx::AI::OpenAICreateResponseParams::Reasoning::OrHash
+          ).void
+        end
+        attr_writer :reasoning
+
         # 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`.
@@ -72,6 +84,8 @@ module Telnyx
             input: T::Hash[Symbol, T.anything],
             instructions: String,
             model: String,
+            reasoning:
+              Telnyx::AI::OpenAICreateResponseParams::Reasoning::OrHash,
             service_tier: String,
             stream: T::Boolean,
             request_options: Telnyx::RequestOptions::OrHash
@@ -92,6 +106,7 @@ module Telnyx
           # 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,
           # 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`.
@@ -110,6 +125,7 @@ module Telnyx
               input: T::Hash[Symbol, T.anything],
               instructions: String,
               model: String,
+              reasoning: Telnyx::AI::OpenAICreateResponseParams::Reasoning,
               service_tier: String,
               stream: T::Boolean,
               request_options: Telnyx::RequestOptions
@@ -118,6 +134,120 @@ module Telnyx
         end
         def to_hash
         end
+
+        class Reasoning < Telnyx::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          # Controls the reasoning effort for models that support it. Same values and
+          # semantics as reasoning_effort on Chat Completions.
+          sig do
+            returns(
+              T.nilable(
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::OrSymbol
+              )
+            )
+          end
+          attr_reader :effort
+
+          sig do
+            params(
+              effort:
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::OrSymbol
+            ).void
+          end
+          attr_writer :effort
+
+          sig do
+            params(
+              effort:
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Controls the reasoning effort for models that support it. Same values and
+            # semantics as reasoning_effort on Chat Completions.
+            effort: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                effort:
+                  Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::OrSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Controls the reasoning effort for models that support it. Same values and
+          # semantics as reasoning_effort on Chat Completions.
+          module Effort
+            extend Telnyx::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            NONE =
+              T.let(
+                :none,
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+              )
+            MINIMAL =
+              T.let(
+                :minimal,
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+              )
+            LOW =
+              T.let(
+                :low,
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+              )
+            MEDIUM =
+              T.let(
+                :medium,
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+              )
+            HIGH =
+              T.let(
+                :high,
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+              )
+            XHIGH =
+              T.let(
+                :xhigh,
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+              )
+            MAX =
+              T.let(
+                :max,
+                Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::AI::OpenAICreateResponseParams::Reasoning::Effort::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
       end
     end
   end

data/rbi/telnyx/models/ai/speak_node.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class SpeakNode < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::SpeakNode, 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::SpeakNode::Type::TaggedSymbol)) }
+        attr_reader :type
+
+        sig { params(type: Telnyx::AI::SpeakNode::Type::OrSymbol).void }
+        attr_writer :type
+
+        # A standalone scripted-message step in a flow, as returned by the API.
+        sig do
+          params(
+            id: String,
+            message: String,
+            name: String,
+            position: Telnyx::AI::NodePosition::OrHash,
+            type: Telnyx::AI::SpeakNode::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::SpeakNode::Type::TaggedSymbol
+            }
+          )
+        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::SpeakNode::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          SPEAK = T.let(:speak, Telnyx::AI::SpeakNode::Type::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Telnyx::AI::SpeakNode::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end