telnyx 5.168.0 → 5.170.0

data/lib/telnyx/resources/ai/memory/namespaces/profiles.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class AI
+      class Memory
+        class Namespaces
+          class Profiles
+            # What a namespace and a profile hold.
+            # @return [Telnyx::Resources::AI::Memory::Namespaces::Profiles::Memories]
+            attr_reader :memories
+
+            # What a profile stored, and what its memories came from.
+            # @return [Telnyx::Resources::AI::Memory::Namespaces::Profiles::Sources]
+            attr_reader :sources
+
+            # Some parameter documentations has been truncated, see
+            # {Telnyx::Models::AI::Memory::Namespaces::ProfileListParams} for more details.
+            #
+            # Profiles are never created, only written to, so this lists the ones that hold a
+            # memory. A profile whose first ingest is still running is not here yet. Ordered
+            # by memory count, largest first, so a profile written to while the listing is
+            # paged can move between pages and be repeated or missed.
+            #
+            # @overload list(namespace, page_number: nil, page_size: nil, request_options: {})
+            #
+            # @param namespace [String]
+            #
+            # @param page_number [Integer] The page to return, counting from 1. Bounded in depth: (page[number] - 1) \*
+            # page
+            #
+            # @param page_size [Integer] How many results a page holds.
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Internal::DefaultFlatPagination<Telnyx::Models::AI::Memory::Namespaces::ProfileListResponse>]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::ProfileListParams
+            def list(namespace, params = {})
+              parsed, options = Telnyx::AI::Memory::Namespaces::ProfileListParams.dump_request(params)
+              query = Telnyx::Internal::Util.encode_query_params(parsed)
+              @client.request(
+                method: :get,
+                path: ["ai/memory/namespaces/%1$s/profiles", namespace],
+                query: query.transform_keys(page_number: "page[number]", page_size: "page[size]"),
+                page: Telnyx::Internal::DefaultFlatPagination,
+                model: Telnyx::Models::AI::Memory::Namespaces::ProfileListResponse,
+                options: options
+              )
+            end
+
+            # Some parameter documentations has been truncated, see
+            # {Telnyx::Models::AI::Memory::Namespaces::ProfileDeleteParams} for more details.
+            #
+            # Delete everything held about one profile. A 2xx means none of its memories are
+            # left, and its summary goes with them. There is no undo.
+            #
+            # @overload delete(profile_id, namespace:, request_options: {})
+            #
+            # @param profile_id [String] The profile: your identifier for the user, caller or agent this memory is about.
+            #
+            # @param namespace [String] The namespace. `default` exists for every organization.
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Models::AI::Memory::Namespaces::ProfileDeleteResponse]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::ProfileDeleteParams
+            def delete(profile_id, params)
+              parsed, options = Telnyx::AI::Memory::Namespaces::ProfileDeleteParams.dump_request(params)
+              namespace =
+                parsed.delete(:namespace) do
+                  raise ArgumentError.new("missing required path argument #{_1}")
+                end
+              @client.request(
+                method: :delete,
+                path: ["ai/memory/namespaces/%1$s/profiles/%2$s", namespace, profile_id],
+                model: Telnyx::Models::AI::Memory::Namespaces::ProfileDeleteResponse,
+                options: options
+              )
+            end
+
+            # Some parameter documentations has been truncated, see
+            # {Telnyx::Models::AI::Memory::Namespaces::ProfileIngestParams} for more details.
+            #
+            # Store a session. Facts are extracted from whatever you send — the body is taken
+            # as any JSON value and stored whole, so a framework's own transcript shape works
+            # unchanged. `messages` of `role`/`content` is the conventional shape, not a
+            # requirement. An empty object or a null body is refused. Carry a `session_id` to
+            # name the session: re-ingesting the same one replaces what it held. Omit it and a
+            # session is opened and returned. Extraction runs asynchronously — poll the
+            # returned operation.
+            #
+            # @overload ingest(profile_id, namespace:, body:, session_id: nil, request_options: {})
+            #
+            # @param profile_id [String] Path param
+            #
+            # @param namespace [String] Path param
+            #
+            # @param body [Hash{Symbol=>Object}, Array<Object>, String, Float, Boolean] Body param: The session's messages, in whatever shape your framework produces. A
+            #
+            # @param session_id [String, nil] Query param: Names the session. Re-ingesting the same session replaces what it h
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Models::AI::Memory::Namespaces::ProfileIngestResponse]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::ProfileIngestParams
+            def ingest(profile_id, params)
+              parsed, options = Telnyx::AI::Memory::Namespaces::ProfileIngestParams.dump_request(params)
+              query = Telnyx::Internal::Util.encode_query_params(parsed.except(:body))
+              namespace =
+                parsed.delete(:namespace) do
+                  raise ArgumentError.new("missing required path argument #{_1}")
+                end
+              @client.request(
+                method: :post,
+                path: ["ai/memory/namespaces/%1$s/profiles/%2$s/ingest", namespace, profile_id],
+                query: query,
+                body: parsed[:body],
+                model: Telnyx::Models::AI::Memory::Namespaces::ProfileIngestResponse,
+                options: options
+              )
+            end
+
+            # Ranked memories for a question. Matching runs over the profile's memories and
+            # returns them in rank order with a relevance `score`; the score is null where the
+            # deployment's reranker is a passthrough, in which case order is the only signal.
+            # No model runs in this path — recall returns facts, it does not compose an
+            # answer.
+            #
+            # @overload recall(profile_id, namespace:, query:, top_k: nil, request_options: {})
+            #
+            # @param profile_id [String] Path param
+            #
+            # @param namespace [String] Path param
+            #
+            # @param query [String] Body param
+            #
+            # @param top_k [Integer, nil] Body param
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Models::AI::Memory::Namespaces::ProfileRecallResponse]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::ProfileRecallParams
+            def recall(profile_id, params)
+              parsed, options = Telnyx::AI::Memory::Namespaces::ProfileRecallParams.dump_request(params)
+              namespace =
+                parsed.delete(:namespace) do
+                  raise ArgumentError.new("missing required path argument #{_1}")
+                end
+              @client.request(
+                method: :post,
+                path: ["ai/memory/namespaces/%1$s/profiles/%2$s/recall", namespace, profile_id],
+                body: parsed,
+                model: Telnyx::Models::AI::Memory::Namespaces::ProfileRecallResponse,
+                options: options
+              )
+            end
+
+            # For a fact the agent has already distilled: `text` is stored as given, with
+            # nothing extracted from it. Send a transcript to `ingest` instead. Remembering
+            # the same text again writes the same memory rather than a second copy of it, so a
+            # retry is safe. The write runs asynchronously -- poll the returned operation.
+            #
+            # @overload remember(profile_id, namespace:, text:, request_options: {})
+            #
+            # @param profile_id [String] Path param
+            #
+            # @param namespace [String] Path param
+            #
+            # @param text [String] Body param
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Models::AI::Memory::Namespaces::ProfileRememberResponse]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::ProfileRememberParams
+            def remember(profile_id, params)
+              parsed, options = Telnyx::AI::Memory::Namespaces::ProfileRememberParams.dump_request(params)
+              namespace =
+                parsed.delete(:namespace) do
+                  raise ArgumentError.new("missing required path argument #{_1}")
+                end
+              @client.request(
+                method: :post,
+                path: ["ai/memory/namespaces/%1$s/profiles/%2$s/remember", namespace, profile_id],
+                body: parsed,
+                model: Telnyx::Models::AI::Memory::Namespaces::ProfileRememberResponse,
+                options: options
+              )
+            end
+
+            # Some parameter documentations has been truncated, see
+            # {Telnyx::Models::AI::Memory::Namespaces::ProfileRetrieveSummaryParams} for more
+            # details.
+            #
+            # The whole profile as one card, precomputed, with no query. Built for the start
+            # of a session, where there is no question to ask yet.
+            #
+            # A summary is generated in the background. `is_stale` tells you newer memories
+            # have arrived since it was written; that is ordinary and the card is still
+            # usable.
+            #
+            # @overload retrieve_summary(profile_id, namespace:, request_options: {})
+            #
+            # @param profile_id [String] The profile: your identifier for the user, caller or agent this memory is about.
+            #
+            # @param namespace [String] The namespace. `default` exists for every organization.
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Models::AI::Memory::Namespaces::ProfileRetrieveSummaryResponse]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::ProfileRetrieveSummaryParams
+            def retrieve_summary(profile_id, params)
+              parsed, options = Telnyx::AI::Memory::Namespaces::ProfileRetrieveSummaryParams.dump_request(params)
+              namespace =
+                parsed.delete(:namespace) do
+                  raise ArgumentError.new("missing required path argument #{_1}")
+                end
+              @client.request(
+                method: :get,
+                path: ["ai/memory/namespaces/%1$s/profiles/%2$s/summary", namespace, profile_id],
+                model: Telnyx::Models::AI::Memory::Namespaces::ProfileRetrieveSummaryResponse,
+                options: options
+              )
+            end
+
+            # @api private
+            #
+            # @param client [Telnyx::Client]
+            def initialize(client:)
+              @client = client
+              @memories = Telnyx::Resources::AI::Memory::Namespaces::Profiles::Memories.new(client: client)
+              @sources = Telnyx::Resources::AI::Memory::Namespaces::Profiles::Sources.new(client: client)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/ai/memory/namespaces/settings.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class AI
+      class Memory
+        class Namespaces
+          # How a namespace's summaries are written.
+          class Settings
+            # What is currently set for this namespace. `instructions: null` means none are
+            # set and summaries use the neutral default.
+            #
+            # @overload list(namespace, request_options: {})
+            #
+            # @param namespace [String] The namespace. `default` exists for every organization.
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Models::AI::Memory::Namespaces::NamespaceSettingsResponse]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::SettingListParams
+            def list(namespace, params = {})
+              @client.request(
+                method: :get,
+                path: ["ai/memory/namespaces/%1$s/settings", namespace],
+                model: Telnyx::AI::Memory::Namespaces::NamespaceSettingsResponse,
+                options: params[:request_options]
+              )
+            end
+
+            # Some parameter documentations has been truncated, see
+            # {Telnyx::Models::AI::Memory::Namespaces::SettingPatchAllParams} for more
+            # details.
+            #
+            # Only the fields you send are changed; anything omitted is left as it is, so `{}`
+            # changes nothing. Sending `instructions: null`, or an empty or whitespace-only
+            # string, clears them and returns summaries to the neutral default.
+            #
+            # Instructions are capped at 2000 characters. A longer note is refused rather than
+            # truncated, because a note cut mid-sentence is a worse steer than none. A change
+            # reaches each summary the next time that summary is regenerated, not immediately.
+            #
+            # @overload patch_all(namespace, summary: nil, request_options: {})
+            #
+            # @param namespace [String] The namespace. `default` exists for every organization.
+            #
+            # @param summary [Telnyx::Models::AI::Memory::Namespaces::SettingPatchAllParams::Summary, nil] A partial update to a namespace's summary settings.
+            #
+            # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+            #
+            # @return [Telnyx::Models::AI::Memory::Namespaces::NamespaceSettingsResponse]
+            #
+            # @see Telnyx::Models::AI::Memory::Namespaces::SettingPatchAllParams
+            def patch_all(namespace, params = {})
+              parsed, options = Telnyx::AI::Memory::Namespaces::SettingPatchAllParams.dump_request(params)
+              @client.request(
+                method: :patch,
+                path: ["ai/memory/namespaces/%1$s/settings", namespace],
+                body: parsed,
+                model: Telnyx::AI::Memory::Namespaces::NamespaceSettingsResponse,
+                options: options
+              )
+            end
+
+            # @api private
+            #
+            # @param client [Telnyx::Client]
+            def initialize(client:)
+              @client = client
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/ai/memory/namespaces.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class AI
+      class Memory
+        # Whether a write has finished.
+        class Namespaces
+          # @return [Telnyx::Resources::AI::Memory::Namespaces::Profiles]
+          attr_reader :profiles
+
+          # How a namespace's summaries are written.
+          # @return [Telnyx::Resources::AI::Memory::Namespaces::Settings]
+          attr_reader :settings
+
+          # Whether a write has finished. Both `ingest` and `remember` return an
+          # `operation_id`, and a memory is not recallable until its operation completes —
+          # extraction, embedding and consolidation all run first.
+          #
+          # @overload retrieve(operation_id, namespace:, request_options: {})
+          #
+          # @param operation_id [String]
+          # @param namespace [String]
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Telnyx::Models::AI::Memory::NamespaceRetrieveResponse]
+          #
+          # @see Telnyx::Models::AI::Memory::NamespaceRetrieveParams
+          def retrieve(operation_id, params)
+            parsed, options = Telnyx::AI::Memory::NamespaceRetrieveParams.dump_request(params)
+            namespace =
+              parsed.delete(:namespace) do
+                raise ArgumentError.new("missing required path argument #{_1}")
+              end
+            @client.request(
+              method: :get,
+              path: ["ai/memory/namespaces/%1$s/operations/%2$s", namespace, operation_id],
+              model: Telnyx::Models::AI::Memory::NamespaceRetrieveResponse,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Telnyx::Client]
+          def initialize(client:)
+            @client = client
+            @profiles = Telnyx::Resources::AI::Memory::Namespaces::Profiles.new(client: client)
+            @settings = Telnyx::Resources::AI::Memory::Namespaces::Settings.new(client: client)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/ai/memory.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class AI
+      class Memory
+        # Whether a write has finished.
+        # @return [Telnyx::Resources::AI::Memory::Namespaces]
+        attr_reader :namespaces
+
+        # @api private
+        #
+        # @param client [Telnyx::Client]
+        def initialize(client:)
+          @client = client
+          @namespaces = Telnyx::Resources::AI::Memory::Namespaces.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/ai/typesafe/v1.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class AI
+      class Typesafe
+        # Beta API for evaluating shared context with typed questions and structured
+        # answers using Flash or Pro.
+        class V1
+          # Some parameter documentations has been truncated, see
+          # {Telnyx::Models::AI::Typesafe::V1SystemoneParams} for more details.
+          #
+          # **Beta API.** Choose telnyx/decision-flash for the lowest cost and latency, or
+          # telnyx/decision-pro for decisions that require long context, including inputs
+          # beyond Jev’s 32k per-decision limit. Omitted model defaults to
+          # telnyx/decision-flash.
+          #
+          # Evaluate shared context using named choice, noul (yes/no), and score questions.
+          # Returns TypeSafe System One-compatible answer shapes, the selected public model
+          # alias, and token usage. See the
+          # [decision model guide](https://developers.telnyx.com/docs/inference/decision-models)
+          # for examples and compatibility limits.
+          #
+          # The supported request subset requires instructions for every question, string
+          # descriptions for criteria (or null for choice descriptions), 1–64 questions, and
+          # 2–64 options for choice and score questions. The model field accepts only
+          # telnyx/decision-flash or telnyx/decision-pro. Unsupported model values and
+          # unknown fields are rejected. The endpoint is synchronous and does not stream.
+          #
+          # Use the TypeSafe Python SDK with base_url set to
+          # https://api.telnyx.com/v2/ai/typesafe and a Telnyx API key. The SDK appends
+          # /v1/systemone; explicitly set model to a supported Telnyx alias because its own
+          # default model is not supported. Compatibility covers this operation and the
+          # documented request subset; it does not include TypeSafe model listing. Scores
+          # describe relative preference, not calibrated correctness.
+          #
+          # @overload systemone(questions:, state:, model: nil, request_options: {})
+          #
+          # @param questions [Hash{Symbol=>Telnyx::Models::AI::Typesafe::V1SystemoneParams::Question::Choice, Telnyx::Models::AI::Typesafe::V1SystemoneParams::Question::Noul, Telnyx::Models::AI::Typesafe::V1SystemoneParams::Question::Score}] Between 1 and 64 named questions. Each key identifies the corresponding answer.
+          #
+          # @param state [String, Hash{Symbol=>Object}, Array<Object>] Shared context evaluated by every question.
+          #
+          # @param model [Symbol, Telnyx::Models::AI::Typesafe::V1SystemoneParams::Model] Public model alias. telnyx/decision-flash offers the lowest cost and latency; te
+          #
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Telnyx::Models::AI::Typesafe::V1SystemoneResponse]
+          #
+          # @see Telnyx::Models::AI::Typesafe::V1SystemoneParams
+          def systemone(params)
+            parsed, options = Telnyx::AI::Typesafe::V1SystemoneParams.dump_request(params)
+            @client.request(
+              method: :post,
+              path: "ai/typesafe/v1/systemone",
+              body: parsed,
+              model: Telnyx::Models::AI::Typesafe::V1SystemoneResponse,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Telnyx::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/ai/typesafe.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class AI
+      class Typesafe
+        # Beta API for evaluating shared context with typed questions and structured
+        # answers using Flash or Pro.
+        # @return [Telnyx::Resources::AI::Typesafe::V1]
+        attr_reader :v1
+
+        # @api private
+        #
+        # @param client [Telnyx::Client]
+        def initialize(client:)
+          @client = client
+          @v1 = Telnyx::Resources::AI::Typesafe::V1.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/ai.rb

@@ -55,6 +55,12 @@ module Telnyx
       # @return [Telnyx::Resources::AI::Knowledge]
       attr_reader :knowledge
 
+      # @return [Telnyx::Resources::AI::Typesafe]
+      attr_reader :typesafe
+
+      # @return [Telnyx::Resources::AI::Memory]
+      attr_reader :memory
+
       # Some parameter documentations has been truncated, see
       # {Telnyx::Models::AIRetrieveConversationHistoriesParams} for more details.
       #
@@ -228,6 +234,8 @@ module Telnyx
         @tools = Telnyx::Resources::AI::Tools.new(client: client)
         @anthropic = Telnyx::Resources::AI::Anthropic.new(client: client)
         @knowledge = Telnyx::Resources::AI::Knowledge.new(client: client)
+        @typesafe = Telnyx::Resources::AI::Typesafe.new(client: client)
+        @memory = Telnyx::Resources::AI::Memory.new(client: client)
       end
     end
   end

data/lib/telnyx/resources/bot_challenge.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    # Agentic (bot) signup for Telnyx accounts. An AI agent solves a reverse-CAPTCHA
+    # challenge designed to be easy for LLMs and hard for humans, registers an
+    # account, and signs in by consuming a magic link emailed to the account owner.
+    # All endpoints are public and unauthenticated; signup endpoints are additionally
+    # gated by the freemium feature flags and per-country availability.
+    class BotChallenge
+      # Generates a reverse-CAPTCHA challenge used to gate the bot signup flow. A random
+      # active problem is selected from the pool; math problems are returned obfuscated
+      # (case randomization, symbol injection, spacing noise) with an unobfuscated
+      # rounding instruction appended, while string and binary problems are returned
+      # as-is. The response contains a single-use nonce, the problem text, and the
+      # current terms-and-conditions and privacy-policy URLs, which must be echoed back
+      # on the signup request. Challenges expire after a short window (10 minutes by
+      # default) and can only be answered once. This endpoint is public and
+      # unauthenticated.
+      #
+      # @overload create(llm_model_name: nil, llm_parameter_count: nil, llm_quantization: nil, request_options: {})
+      #
+      # @param llm_model_name [String] Name of the LLM the client is using.
+      #
+      # @param llm_parameter_count [String] Parameter count of the client LLM.
+      #
+      # @param llm_quantization [String] Quantization of the client LLM.
+      #
+      # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Telnyx::Models::BotChallengeCreateResponse]
+      #
+      # @see Telnyx::Models::BotChallengeCreateParams
+      def create(params = {})
+        parsed, options = Telnyx::BotChallengeCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/bot_challenge",
+          body: parsed,
+          model: Telnyx::Models::BotChallengeCreateResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Telnyx::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/telnyx/resources/bot_sessions.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    # Agentic (bot) signup for Telnyx accounts. An AI agent solves a reverse-CAPTCHA
+    # challenge designed to be easy for LLMs and hard for humans, registers an
+    # account, and signs in by consuming a magic link emailed to the account owner.
+    # All endpoints are public and unauthenticated; signup endpoints are additionally
+    # gated by the freemium feature flags and per-country availability.
+    class BotSessions
+      # Some parameter documentations has been truncated, see
+      # {Telnyx::Models::BotSessionListParams} for more details.
+      #
+      # Consumes the one-time portal redirect (magic link) token emailed during bot
+      # signup and returns an API session. The token is a UUIDv7 that encodes its
+      # creation time; it expires after a configurable validity window (15 minutes by
+      # default) and is cleared on first use. Although the action creates a session, the
+      # route uses the GET verb because it is opened from an email link. On first use
+      # the account is also initialized. For bot signup (freemium) accounts the response
+      # is a minimal envelope containing only the `api_v2_token`; accounts that are
+      # permitted to use magic links but are not freemium accounts may instead receive
+      # an extended session payload when additional steps (such as two-factor
+      # authentication or identity verification) are required. This endpoint is public;
+      # the magic link token in the query string is the credential.
+      #
+      # @overload list(email:, portal_redirect_token:, request_options: {})
+      #
+      # @param email [String] Email address associated with the magic link token.
+      #
+      # @param portal_redirect_token [String] Single-use portal redirect (magic link) token, a UUIDv7 sent to the account owne
+      #
+      # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Telnyx::Models::BotSessionListResponse]
+      #
+      # @see Telnyx::Models::BotSessionListParams
+      def list(params)
+        parsed, options = Telnyx::BotSessionListParams.dump_request(params)
+        query = Telnyx::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "v2/bot_sessions",
+          query: query,
+          model: Telnyx::Models::BotSessionListResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Telnyx::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end