telnyx 5.162.0 → 5.164.0

data/rbi/telnyx/models/ai/inference_embedding_webhook_tool_params.rbi

@@ -168,6 +168,38 @@ module Telnyx
           end
           attr_writer :headers
 
+          # Filler messages spoken while a synchronous webhook request is in progress.
+          # `request_start` messages are spoken immediately when the request begins.
+          # `request_response_delayed` messages are spoken after `timing_ms` has elapsed
+          # only if the webhook response is still pending. Filler messages are not used for
+          # asynchronous webhooks.
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  T.any(
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestStartMessage,
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestResponseDelayedMessage
+                  )
+                ]
+              )
+            )
+          end
+          attr_reader :messages
+
+          sig do
+            params(
+              messages:
+                T::Array[
+                  T.any(
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestStartMessage::OrHash,
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestResponseDelayedMessage::OrHash
+                  )
+                ]
+            ).void
+          end
+          attr_writer :messages
+
           # The HTTP method to be used when calling the external tool.
           sig do
             returns(
@@ -208,6 +240,33 @@ module Telnyx
           end
           attr_writer :path_parameters
 
+          # Body fields supplied by the assistant configuration rather than by the model.
+          # They are never advertised in the tool definition, so the LLM can neither see nor
+          # set them, and they take precedence over a `body_parameters` value of the same
+          # name. Values support mustache templating, so they can hold dynamic variables
+          # (`{{customer_id}}`) and integration secrets
+          # (`{{#integration_secret}}my-secret{{/integration_secret}}`). Not sent on `GET`
+          # requests, which carry no body.
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_reader :preset_body_fields
+
+          sig { params(preset_body_fields: T::Hash[Symbol, T.anything]).void }
+          attr_writer :preset_body_fields
+
+          # Query string parameters supplied by the assistant configuration rather than by
+          # the model. They are never advertised in the tool definition, so the LLM can
+          # neither see nor set them, and they take precedence over a `query_parameters`
+          # value of the same name. Values support mustache templating, so they can hold
+          # dynamic variables (`{{telnyx_end_user_target}}`) and integration secrets
+          # (`{{#integration_secret}}my-secret{{/integration_secret}}`). Unlike values
+          # templated directly into the `url`, these are percent-encoded, so a value such as
+          # `+15551234567` survives the round trip.
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_reader :preset_query_params
+
+          sig { params(preset_query_params: T::Hash[Symbol, T.anything]).void }
+          attr_writer :preset_query_params
+
           # The query parameters the webhook tool accepts, described as a JSON Schema
           # object. These parameters will be passed to the webhook as the query of the
           # request. See the
@@ -275,10 +334,19 @@ module Telnyx
                 T::Array[
                   Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Header::OrHash
                 ],
+              messages:
+                T::Array[
+                  T.any(
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestStartMessage::OrHash,
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestResponseDelayedMessage::OrHash
+                  )
+                ],
               http_method:
                 Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Method::OrSymbol,
               path_parameters:
                 Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::PathParameters::OrHash,
+              preset_body_fields: T::Hash[Symbol, T.anything],
+              preset_query_params: T::Hash[Symbol, T.anything],
               query_parameters:
                 Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::QueryParameters::OrHash,
               store_fields_as_variables:
@@ -312,6 +380,12 @@ module Telnyx
             body_parameters: nil,
             # The headers to be sent to the external tool.
             headers: nil,
+            # Filler messages spoken while a synchronous webhook request is in progress.
+            # `request_start` messages are spoken immediately when the request begins.
+            # `request_response_delayed` messages are spoken after `timing_ms` has elapsed
+            # only if the webhook response is still pending. Filler messages are not used for
+            # asynchronous webhooks.
+            messages: nil,
             # The HTTP method to be used when calling the external tool.
             http_method: nil,
             # The path parameters the webhook tool accepts, described as a JSON Schema object.
@@ -320,6 +394,23 @@ module Telnyx
             # [JSON Schema reference](https://json-schema.org/understanding-json-schema) for
             # documentation about the format
             path_parameters: nil,
+            # Body fields supplied by the assistant configuration rather than by the model.
+            # They are never advertised in the tool definition, so the LLM can neither see nor
+            # set them, and they take precedence over a `body_parameters` value of the same
+            # name. Values support mustache templating, so they can hold dynamic variables
+            # (`{{customer_id}}`) and integration secrets
+            # (`{{#integration_secret}}my-secret{{/integration_secret}}`). Not sent on `GET`
+            # requests, which carry no body.
+            preset_body_fields: nil,
+            # Query string parameters supplied by the assistant configuration rather than by
+            # the model. They are never advertised in the tool definition, so the LLM can
+            # neither see nor set them, and they take precedence over a `query_parameters`
+            # value of the same name. Values support mustache templating, so they can hold
+            # dynamic variables (`{{telnyx_end_user_target}}`) and integration secrets
+            # (`{{#integration_secret}}my-secret{{/integration_secret}}`). Unlike values
+            # templated directly into the `url`, these are percent-encoded, so a value such as
+            # `+15551234567` survives the round trip.
+            preset_query_params: nil,
             # The query parameters the webhook tool accepts, described as a JSON Schema
             # object. These parameters will be passed to the webhook as the query of the
             # request. See the
@@ -350,10 +441,19 @@ module Telnyx
                   T::Array[
                     Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Header
                   ],
+                messages:
+                  T::Array[
+                    T.any(
+                      Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestStartMessage,
+                      Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestResponseDelayedMessage
+                    )
+                  ],
                 http_method:
                   Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Method::OrSymbol,
                 path_parameters:
                   Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::PathParameters,
+                preset_body_fields: T::Hash[Symbol, T.anything],
+                preset_query_params: T::Hash[Symbol, T.anything],
                 query_parameters:
                   Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::QueryParameters,
                 store_fields_as_variables:
@@ -518,6 +618,127 @@ module Telnyx
             end
           end
 
+          module Message
+            extend Telnyx::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestStartMessage,
+                  Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestResponseDelayedMessage
+                )
+              end
+
+            class WebhookToolRequestStartMessage < Telnyx::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestStartMessage,
+                    Telnyx::Internal::AnyHash
+                  )
+                end
+
+              # The text the assistant speaks.
+              sig { returns(String) }
+              attr_accessor :content
+
+              # Speak the filler message immediately when the webhook request begins.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              # An optional delay value. This value is ignored for `request_start` messages.
+              sig { returns(T.nilable(Integer)) }
+              attr_reader :timing_ms
+
+              sig { params(timing_ms: Integer).void }
+              attr_writer :timing_ms
+
+              sig do
+                params(
+                  content: String,
+                  timing_ms: Integer,
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The text the assistant speaks.
+                content:,
+                # An optional delay value. This value is ignored for `request_start` messages.
+                timing_ms: nil,
+                # Speak the filler message immediately when the webhook request begins.
+                type: :request_start
+              )
+              end
+
+              sig do
+                override.returns(
+                  { content: String, type: Symbol, timing_ms: Integer }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class WebhookToolRequestResponseDelayedMessage < Telnyx::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::WebhookToolRequestResponseDelayedMessage,
+                    Telnyx::Internal::AnyHash
+                  )
+                end
+
+              # The text the assistant speaks.
+              sig { returns(String) }
+              attr_accessor :content
+
+              # The delay in milliseconds from the start of the webhook request.
+              sig { returns(Integer) }
+              attr_accessor :timing_ms
+
+              # Speak the filler message after the configured delay if the webhook response is
+              # still pending.
+              sig { returns(Symbol) }
+              attr_accessor :type
+
+              sig do
+                params(
+                  content: String,
+                  timing_ms: Integer,
+                  type: Symbol
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # The text the assistant speaks.
+                content:,
+                # The delay in milliseconds from the start of the webhook request.
+                timing_ms:,
+                # Speak the filler message after the configured delay if the webhook response is
+                # still pending.
+                type: :request_response_delayed
+              )
+              end
+
+              sig do
+                override.returns(
+                  { content: String, timing_ms: Integer, type: Symbol }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::AI::InferenceEmbeddingWebhookToolParams::Webhook::Message::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
           # The HTTP method to be used when calling the external tool.
           module Method
             extend Telnyx::Internal::Type::Enum

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

@@ -0,0 +1,206 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      module Knowledge
+        class CollectionRetrieveDocumentsParams < Telnyx::Internal::Type::BaseModel
+          extend Telnyx::Internal::Type::RequestParameters::Converter
+          include Telnyx::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams,
+                Telnyx::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :slug
+
+          # Field filters applied before ranking, using `filter[field][operator]=value`.
+          # Supported operators: `eq` (default), `in`, `gte`, `gt`, `lte`, `lt`, `contains`.
+          # Known fields: `record_type`, `record_id`, `user_id`, `record_created_at`,
+          # `ingested_at`; any other name resolves to a `metadata.<field>` filter. Example:
+          # `filter[record_id][eq]=rec_123`.
+          sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+          attr_reader :filter
+
+          sig { params(filter: T::Hash[Symbol, T.anything]).void }
+          attr_writer :filter
+
+          # Page number to return (1-based). Defaults to 1.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :page_number
+
+          sig { params(page_number: Integer).void }
+          attr_writer :page_number
+
+          # Number of results per page. Defaults to 20.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :page_size
+
+          sig { params(page_size: Integer).void }
+          attr_writer :page_size
+
+          # Natural-language search query. When provided, the text is matched against the
+          # collection's document chunks using the collection's `retrieval_type` (vector or
+          # hybrid). When omitted, documents are returned as a plain catalog listing.
+          sig { returns(T.nilable(String)) }
+          attr_reader :query
+
+          sig { params(query: String).void }
+          attr_writer :query
+
+          # Reserved; not yet functional. A value supplied here is accepted but ignored — it
+          # does not override the collection's configured strategy, and it is not echoed
+          # back. Searches run `vector` retrieval, and `meta.retrieval_type` reports the
+          # mode that actually ran. To change retrieval strategy, set it on the collection's
+          # settings subresource.
+          sig do
+            returns(
+              T.nilable(
+                Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol
+              )
+            )
+          end
+          attr_reader :retrieval_type
+
+          sig do
+            params(
+              retrieval_type:
+                Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol
+            ).void
+          end
+          attr_writer :retrieval_type
+
+          # Comma-separated list of source types to restrict the search to. When omitted,
+          # all of the collection's sources are searched.
+          sig { returns(T.nilable(String)) }
+          attr_reader :sources
+
+          sig { params(sources: String).void }
+          attr_writer :sources
+
+          # Maximum number of ranked results to consider. When omitted, the collection's
+          # configured `top_k` setting is used.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :top_k
+
+          sig { params(top_k: Integer).void }
+          attr_writer :top_k
+
+          sig do
+            params(
+              slug: String,
+              filter: T::Hash[Symbol, T.anything],
+              page_number: Integer,
+              page_size: Integer,
+              query: String,
+              retrieval_type:
+                Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol,
+              sources: String,
+              top_k: Integer,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            slug:,
+            # Field filters applied before ranking, using `filter[field][operator]=value`.
+            # Supported operators: `eq` (default), `in`, `gte`, `gt`, `lte`, `lt`, `contains`.
+            # Known fields: `record_type`, `record_id`, `user_id`, `record_created_at`,
+            # `ingested_at`; any other name resolves to a `metadata.<field>` filter. Example:
+            # `filter[record_id][eq]=rec_123`.
+            filter: nil,
+            # Page number to return (1-based). Defaults to 1.
+            page_number: nil,
+            # Number of results per page. Defaults to 20.
+            page_size: nil,
+            # Natural-language search query. When provided, the text is matched against the
+            # collection's document chunks using the collection's `retrieval_type` (vector or
+            # hybrid). When omitted, documents are returned as a plain catalog listing.
+            query: nil,
+            # Reserved; not yet functional. A value supplied here is accepted but ignored — it
+            # does not override the collection's configured strategy, and it is not echoed
+            # back. Searches run `vector` retrieval, and `meta.retrieval_type` reports the
+            # mode that actually ran. To change retrieval strategy, set it on the collection's
+            # settings subresource.
+            retrieval_type: nil,
+            # Comma-separated list of source types to restrict the search to. When omitted,
+            # all of the collection's sources are searched.
+            sources: nil,
+            # Maximum number of ranked results to consider. When omitted, the collection's
+            # configured `top_k` setting is used.
+            top_k: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                slug: String,
+                filter: T::Hash[Symbol, T.anything],
+                page_number: Integer,
+                page_size: Integer,
+                query: String,
+                retrieval_type:
+                  Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::OrSymbol,
+                sources: String,
+                top_k: Integer,
+                request_options: Telnyx::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Reserved; not yet functional. A value supplied here is accepted but ignored — it
+          # does not override the collection's configured strategy, and it is not echoed
+          # back. Searches run `vector` retrieval, and `meta.retrieval_type` reports the
+          # mode that actually ran. To change retrieval strategy, set it on the collection's
+          # settings subresource.
+          module RetrievalType
+            extend Telnyx::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            VECTOR =
+              T.let(
+                :vector,
+                Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+              )
+            HYBRID =
+              T.let(
+                :hybrid,
+                Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+              )
+            KEYWORD =
+              T.let(
+                :keyword,
+                Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Telnyx::AI::Knowledge::CollectionRetrieveDocumentsParams::RetrievalType::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end