telnyx 5.64.0 → 5.65.0

data/rbi/telnyx/models/ai/tool_create_response.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolCreateResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::AI::ToolCreateResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :tool_definition
+
+        sig { returns(String) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :created_at
+
+        sig { params(created_at: String).void }
+        attr_writer :created_at
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :display_name
+
+        sig { params(display_name: String).void }
+        attr_writer :display_name
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :timeout_ms
+
+        sig { params(timeout_ms: Integer).void }
+        attr_writer :timeout_ms
+
+        sig do
+          params(
+            id: String,
+            tool_definition: T::Hash[Symbol, T.anything],
+            type: String,
+            created_at: String,
+            display_name: String,
+            timeout_ms: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          tool_definition:,
+          type:,
+          created_at: nil,
+          display_name: nil,
+          timeout_ms: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              tool_definition: T::Hash[Symbol, T.anything],
+              type: String,
+              created_at: String,
+              display_name: String,
+              timeout_ms: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_delete_params.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolDeleteParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::ToolDeleteParams, Telnyx::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :tool_id
+
+        sig do
+          params(
+            tool_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(tool_id:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { tool_id: String, request_options: Telnyx::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_delete_response.rbi

@@ -0,0 +1,9 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      ToolDeleteResponse = T.let(T.anything, Telnyx::Internal::Type::Converter)
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_list_params.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolListParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::ToolListParams, Telnyx::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :filter_name
+
+        sig { params(filter_name: String).void }
+        attr_writer :filter_name
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :filter_type
+
+        sig { params(filter_type: String).void }
+        attr_writer :filter_type
+
+        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 do
+          params(
+            filter_name: String,
+            filter_type: String,
+            page_number: Integer,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          filter_name: nil,
+          filter_type: nil,
+          page_number: nil,
+          page_size: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              filter_name: String,
+              filter_type: String,
+              page_number: Integer,
+              page_size: Integer,
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_list_response.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolListResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::AI::ToolListResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :tool_definition
+
+        sig { returns(String) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :created_at
+
+        sig { params(created_at: String).void }
+        attr_writer :created_at
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :display_name
+
+        sig { params(display_name: String).void }
+        attr_writer :display_name
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :timeout_ms
+
+        sig { params(timeout_ms: Integer).void }
+        attr_writer :timeout_ms
+
+        sig do
+          params(
+            id: String,
+            tool_definition: T::Hash[Symbol, T.anything],
+            type: String,
+            created_at: String,
+            display_name: String,
+            timeout_ms: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          tool_definition:,
+          type:,
+          created_at: nil,
+          display_name: nil,
+          timeout_ms: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              tool_definition: T::Hash[Symbol, T.anything],
+              type: String,
+              created_at: String,
+              display_name: String,
+              timeout_ms: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_retrieve_params.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolRetrieveParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::ToolRetrieveParams, Telnyx::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :tool_id
+
+        sig do
+          params(
+            tool_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(tool_id:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { tool_id: String, request_options: Telnyx::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_retrieve_response.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolRetrieveResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::AI::ToolRetrieveResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :tool_definition
+
+        sig { returns(String) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :created_at
+
+        sig { params(created_at: String).void }
+        attr_writer :created_at
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :display_name
+
+        sig { params(display_name: String).void }
+        attr_writer :display_name
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :timeout_ms
+
+        sig { params(timeout_ms: Integer).void }
+        attr_writer :timeout_ms
+
+        sig do
+          params(
+            id: String,
+            tool_definition: T::Hash[Symbol, T.anything],
+            type: String,
+            created_at: String,
+            display_name: String,
+            timeout_ms: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          tool_definition:,
+          type:,
+          created_at: nil,
+          display_name: nil,
+          timeout_ms: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              tool_definition: T::Hash[Symbol, T.anything],
+              type: String,
+              created_at: String,
+              display_name: String,
+              timeout_ms: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_update_params.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolUpdateParams < Telnyx::Internal::Type::BaseModel
+        extend Telnyx::Internal::Type::RequestParameters::Converter
+        include Telnyx::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Telnyx::AI::ToolUpdateParams, Telnyx::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :tool_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :display_name
+
+        sig { params(display_name: String).void }
+        attr_writer :display_name
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :function
+
+        sig { params(function: T::Hash[Symbol, T.anything]).void }
+        attr_writer :function
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :handoff
+
+        sig { params(handoff: T::Hash[Symbol, T.anything]).void }
+        attr_writer :handoff
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :invite
+
+        sig { params(invite: T::Hash[Symbol, T.anything]).void }
+        attr_writer :invite
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :retrieval
+
+        sig { params(retrieval: T::Hash[Symbol, T.anything]).void }
+        attr_writer :retrieval
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :timeout_ms
+
+        sig { params(timeout_ms: Integer).void }
+        attr_writer :timeout_ms
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :type
+
+        sig { params(type: String).void }
+        attr_writer :type
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :webhook
+
+        sig { params(webhook: T::Hash[Symbol, T.anything]).void }
+        attr_writer :webhook
+
+        sig do
+          params(
+            tool_id: String,
+            display_name: String,
+            function: T::Hash[Symbol, T.anything],
+            handoff: T::Hash[Symbol, T.anything],
+            invite: T::Hash[Symbol, T.anything],
+            retrieval: T::Hash[Symbol, T.anything],
+            timeout_ms: Integer,
+            type: String,
+            webhook: T::Hash[Symbol, T.anything],
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          tool_id:,
+          display_name: nil,
+          function: nil,
+          handoff: nil,
+          invite: nil,
+          retrieval: nil,
+          timeout_ms: nil,
+          type: nil,
+          webhook: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              tool_id: String,
+              display_name: String,
+              function: T::Hash[Symbol, T.anything],
+              handoff: T::Hash[Symbol, T.anything],
+              invite: T::Hash[Symbol, T.anything],
+              retrieval: T::Hash[Symbol, T.anything],
+              timeout_ms: Integer,
+              type: String,
+              webhook: T::Hash[Symbol, T.anything],
+              request_options: Telnyx::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models/ai/tool_update_response.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    module AI
+      class ToolUpdateResponse < Telnyx::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Telnyx::Models::AI::ToolUpdateResponse,
+              Telnyx::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :tool_definition
+
+        sig { returns(String) }
+        attr_accessor :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :created_at
+
+        sig { params(created_at: String).void }
+        attr_writer :created_at
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :display_name
+
+        sig { params(display_name: String).void }
+        attr_writer :display_name
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :timeout_ms
+
+        sig { params(timeout_ms: Integer).void }
+        attr_writer :timeout_ms
+
+        sig do
+          params(
+            id: String,
+            tool_definition: T::Hash[Symbol, T.anything],
+            type: String,
+            created_at: String,
+            display_name: String,
+            timeout_ms: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          tool_definition:,
+          type:,
+          created_at: nil,
+          display_name: nil,
+          timeout_ms: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              tool_definition: T::Hash[Symbol, T.anything],
+              type: String,
+              created_at: String,
+              display_name: String,
+              timeout_ms: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,28 @@ module Telnyx
       class Assistants
         # Configure AI assistant specifications
         class Tools
+          # Add Assistant Tool
+          sig do
+            params(
+              tool_id: String,
+              assistant_id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(T.anything)
+          end
+          def add(tool_id, assistant_id:, request_options: {})
+          end
+
+          # Remove Assistant Tool
+          sig do
+            params(
+              tool_id: String,
+              assistant_id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(T.anything)
+          end
+          def remove(tool_id, assistant_id:, request_options: {})
+          end
+
           # Test a webhook tool for an assistant
           sig do
             params(

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

@@ -45,6 +45,7 @@ module Telnyx
               name: String,
               privacy_settings: Telnyx::AI::PrivacySettings::OrHash,
               telephony_settings: Telnyx::AI::TelephonySettings::OrHash,
+              tool_ids: T::Array[String],
               tools:
                 T::Array[
                   T.any(
@@ -112,6 +113,8 @@ module Telnyx
             privacy_settings: nil,
             # Body param
             telephony_settings: nil,
+            # Body param
+            tool_ids: nil,
             # Body param: The tools that the assistant can use. These may be templated with
             # [dynamic variables](https://developers.telnyx.com/docs/inference/ai-assistants/dynamic-variables)
             tools: nil,

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

@@ -45,6 +45,7 @@ module Telnyx
             messaging_settings: Telnyx::AI::MessagingSettings::OrHash,
             privacy_settings: Telnyx::AI::PrivacySettings::OrHash,
             telephony_settings: Telnyx::AI::TelephonySettings::OrHash,
+            tool_ids: T::Array[String],
             tools:
               T::Array[
                 T.any(
@@ -101,6 +102,7 @@ module Telnyx
           messaging_settings: nil,
           privacy_settings: nil,
           telephony_settings: nil,
+          tool_ids: nil,
           # The tools that the assistant can use. These may be templated with
           # [dynamic variables](https://developers.telnyx.com/docs/inference/ai-assistants/dynamic-variables)
           tools: nil,
@@ -151,6 +153,7 @@ module Telnyx
             privacy_settings: Telnyx::AI::PrivacySettings::OrHash,
             promote_to_main: T::Boolean,
             telephony_settings: Telnyx::AI::TelephonySettings::OrHash,
+            tool_ids: T::Array[String],
             tools:
               T::Array[
                 T.any(
@@ -211,6 +214,7 @@ module Telnyx
           # to true.
           promote_to_main: nil,
           telephony_settings: nil,
+          tool_ids: nil,
           # The tools that the assistant can use. These may be templated with
           # [dynamic variables](https://developers.telnyx.com/docs/inference/ai-assistants/dynamic-variables)
           tools: nil,