telnyx 3.0.5 → 3.1.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c54ee2fae1e5040ea3a33bab7b8d103e0727f9a4bfd966d3ce33bd8c5fef194
-  data.tar.gz: f9c16f95c3bf511e70002362b18caf01f4455bbfcb79252946b665f968b1131d
+  metadata.gz: 84d4e73bfaa1a623aa43940a4f86155b938703fc3d7cf70ffa76b97569c70c35
+  data.tar.gz: e29d1cc3c049e1d38f2b1c49e09f365f55abac868a5684805db0fe6d72294b36
 SHA512:
-  metadata.gz: 19b78fe8dab94fc40f4ed470339e612dccd1db21b059d5ee58620f57f3d02035d1aece4778d9c0179cb9f212908c62e8bddbe26894dae231dd823293b22ba2a3
-  data.tar.gz: 8065a019140e93780bd21c69b3479b02ebd2b90ddf1b29945e2053c768e811e12d11aa9e94f28de3ffd5f42d3a4bec576b6f8aa5b39bb132c5860cacffc901d1
+  metadata.gz: c40236177980cbbc70d98075f11dfceb67661a8bc4a8c8660c03b961aadc2375c79f29f637952f53e1452d549c42e3d722bde7e4a7acfd7932e5a57f7ab0800b
+  data.tar.gz: 8e0c010b5699e9fb409d32d2eeee5c759c36391e4360f83e834c1f375b86c1ec79fee48cf6a0ea9734f758f05103f1339ea5cb185de4a647e9eece2dd26d4dda

data/.github/workflows/publish-gem.yml

@@ -0,0 +1,39 @@
+# Publishes the gem to rubygems.org when a GitHub release is published on the
+# legacy-3.x line (pre-releases included). It can also be run manually to
+# re-publish in case it failed:
+# https://www.github.com/team-telnyx/telnyx-ruby/actions/workflows/publish-gem.yml
+#
+# Same shape as publish-gem.yml on master: RubyGems trusted publishing (OIDC),
+# no API-key secret. The release tag must equal "v#{Telnyx::VERSION}".
+name: Publish Gem
+on:
+  workflow_dispatch:
+
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: publish
+    # Match master: the pinned setup-ruby does not support ubuntu-latest's 26.04 image.
+    runs-on: ubuntu-24.04
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
+        with:
+          ruby-version: "3.2"
+          bundler-cache: false
+
+      - name: Configure RubyGems Credentials
+        uses: rubygems/configure-rubygems-credentials@6861877652452567c1a007a50badad3d316fc9ba
+
+      - name: Publish to RubyGems.org
+        env:
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+        run: |
+          bash ./bin/publish-gem

data/CHANGELOG.md

@@ -1,2 +1,7 @@
 # Changelog
 
+## 3.1.0.pre.1 - 2026-10-29
+Prerelease of 3.1.0. Not resolved by `~> 3.0`; opt in with `gem "telnyx", "3.1.0.pre.1"`.
+* Add `Telnyx::AccessToken` and `TelephonyCredential#to_jwt`: mint a WebRTC login token locally from the credential's `token_material`, with no request to Telnyx per token.
+* Add `TelephonyCredential#fetch_token_material`, backed by `GET /v2/telephony_credentials/:id/token_material` when the object did not come from `create`.
+

data/VERSION

@@ -1 +1 @@
-3.0.5
+3.1.0.pre.1

data/bin/publish-gem

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Build telnyx.gemspec and push the result to rubygems.org.
+# When run from a GitHub release, refuse to publish unless the release tag is
+# exactly "v<Telnyx::VERSION>", so a mistagged release cannot ship the wrong version.
+
+set -Eeuo pipefail
+
+cd -- "$(dirname -- "$0")/.."
+
+version=$(ruby -Ilib -e 'require "telnyx/version"; print Telnyx::VERSION')
+
+if [ -n "${RELEASE_TAG:-}" ] && [ "$RELEASE_TAG" != "v$version" ]; then
+  echo "release tag '$RELEASE_TAG' does not match lib/telnyx/version.rb ('v$version')" >&2
+  exit 1
+fi
+
+find . -maxdepth 1 -type f -name "*.gem" -delete
+gem build telnyx.gemspec
+gem push "telnyx-$version.gem"

data/lib/telnyx/access_token.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "openssl"
+
+module Telnyx
+  # Mints a WebRTC login token for a telephony credential locally, with no
+  # request to Telnyx.
+  #
+  # The token has the same shape as the one `POST /v2/telephony_credentials/:id/token`
+  # returns, so it is used the same way: pass it to the WebRTC SDK as
+  # `login_token`. Telnyx verifies it on login.
+  #
+  # The signing material comes from the credential: `token_material` is in the
+  # response of `POST /v2/telephony_credentials` and of
+  # `GET /v2/telephony_credentials/:id/token_material`. It is as sensitive as
+  # the SIP password, so keep it on the server; never ship it to a browser.
+  #
+  #   credential = Telnyx::TelephonyCredential.create(connection_id: "123")
+  #   credential.to_jwt                   # 1 hour
+  #   credential.to_jwt(ttl: 600)         # 10 minutes
+  #
+  # Or from stored values, without a TelephonyCredential object:
+  #
+  #   Telnyx::AccessToken.new(
+  #     credential_id: "...", user_id: "...", identity: "gencred...",
+  #     expires_at: "2027-01-01T00:00:00Z",
+  #     token_material: { kid: "v1", tel_token: "...", signing_secret: "..." }
+  #   ).to_jwt
+  class AccessToken
+    DEFAULT_TTL = 3600
+    MAX_TTL = 86_400
+    CONTENT_TYPE = "telnyx-webrtc;v=1"
+    ALGORITHM = "HS256"
+
+    MATERIAL_FIELDS = %i[kid tel_token signing_secret].freeze
+
+    attr_reader :credential_id, :user_id, :identity, :expires_at, :ttl
+
+    # @param credential_id [String] the telephony credential `id`
+    # @param user_id [String] the credential's `user_id`
+    # @param identity [String] the credential's `sip_username`
+    # @param expires_at [String, nil] the credential's `expires_at`, as the API returns it
+    # @param token_material [Hash, TelnyxObject] `kid`, `tel_token`, `signing_secret`
+    # @param ttl [Integer] token lifetime in seconds, 1..86400; default one hour
+    def initialize(credential_id:, user_id:, identity:, token_material:, expires_at: nil, ttl: DEFAULT_TTL)
+      @credential_id = required(credential_id, "credential_id")
+      @user_id = required(user_id, "user_id")
+      @identity = required(identity, "identity")
+      @expires_at = expires_at
+      @material = normalize_material(token_material)
+      @ttl = ttl.to_i.clamp(1, MAX_TTL)
+    end
+
+    # The signed token, valid from now for `ttl` seconds.
+    def to_jwt(now: Time.now)
+      iat = now.to_i
+      header = {
+        alg: ALGORITHM,
+        typ: "JWT",
+        cty: CONTENT_TYPE,
+        kid: @material[:kid],
+      }
+      payload = {
+        sub: credential_id,
+        user_id: user_id,
+        identity: identity,
+        cred_exp: expires_at,
+        tel_token: @material[:tel_token],
+        iat: iat,
+        nbf: iat,
+        exp: iat + ttl,
+        jti: "#{credential_id}-#{iat}",
+      }
+
+      signing_input = "#{encode(JSON.generate(header))}.#{encode(JSON.generate(payload))}"
+      "#{signing_input}.#{encode(self.class.sign(signing_input, @material[:signing_secret]))}"
+    end
+
+    alias to_s to_jwt
+
+    # Decodes a token minted by this class and checks its signature against
+    # `signing_secret`. Returns the claims as a Hash with string keys. Meant for
+    # tests and debugging: Telnyx does the real verification on login.
+    def self.decode(jwt, signing_secret:)
+      head, body, sig = jwt.to_s.split(".")
+      raise ArgumentError, "not a JWT" if sig.nil?
+
+      expected = sign("#{head}.#{body}", signing_secret)
+      given = Base64.urlsafe_decode64(sig)
+      valid = given.bytesize == expected.bytesize && OpenSSL.fixed_length_secure_compare(given, expected)
+      raise SignatureVerificationError.new("Signature is invalid and does not match the payload", sig) unless valid
+
+      JSON.parse(Base64.urlsafe_decode64(body))
+    end
+
+    def self.sign(signing_input, signing_secret)
+      key = Base64.urlsafe_decode64(signing_secret)
+      OpenSSL::HMAC.digest("SHA256", key, signing_input)
+    end
+
+    private
+
+    def encode(bytes)
+      Base64.urlsafe_encode64(bytes, padding: false)
+    end
+
+    def required(value, name)
+      raise ArgumentError, "#{name} is required to mint a token" if value.nil? || value.to_s.empty?
+
+      value.to_s
+    end
+
+    def normalize_material(material)
+      hash = material.respond_to?(:to_hash) ? material.to_hash : material
+      raise ArgumentError, "token_material is required to mint a token" unless hash.is_a?(Hash)
+
+      MATERIAL_FIELDS.each_with_object({}) do |field, acc|
+        value = hash[field] || hash[field.to_s]
+        raise ArgumentError, "token_material.#{field} is missing" if value.nil? || value.to_s.empty?
+
+        acc[field] = value.to_s
+      end
+    end
+  end
+end

data/lib/telnyx/api_operations/param_wrapper.rb

@@ -13,10 +13,13 @@ module Telnyx
 
       def wrap(method_name, wrapper)
         define_singleton_method(method_name) do |filters = {}, opts = {}|
-          return super(filters, opts) if filters.keys == [wrapper]
-
-          filters = { wrapper => filters }
-          super filters, opts
+          # If the only key is the wrapper key (e.g., 'filter'), pass it through as is
+          if filters.keys == [wrapper.to_sym] || filters.keys == [wrapper.to_s]
+            super(filters, opts)
+          else
+            # Otherwise, wrap the parameters in the wrapper key
+            super({ wrapper => filters }, opts)
+          end
         end
       end
     end

data/lib/telnyx/telephony_credential.rb

@@ -23,6 +23,37 @@ module Telnyx
       Util.convert_to_telnyx_object(resp.data, opts)
     end
 
+    # A WebRTC login token for this credential, minted locally with no
+    # request to Telnyx. Same use as `create_token`: hand it to the WebRTC
+    # SDK as `login_token`.
+    #
+    # The signing material (`kid`, `tel_token`, `signing_secret`) is read from
+    # `token_material`, present on objects that came from `create`; an object
+    # from `retrieve` or `list` fetches it once (see `fetch_token_material`).
+    # Pass `token_material:` to mint from values stored earlier, with no
+    # request at all.
+    #
+    # `ttl` is the token lifetime in seconds, 1..86400, default one hour.
+    def to_jwt(ttl: AccessToken::DEFAULT_TTL, token_material: nil, opts: {})
+      AccessToken.new(
+        credential_id: id,
+        user_id: self[:user_id],
+        identity: self[:sip_username],
+        expires_at: self[:expires_at],
+        token_material: token_material || self[:token_material] || fetch_token_material(opts),
+        ttl: ttl
+      ).to_jwt
+    end
+
+    # `GET /v2/telephony_credentials/:id/token_material`, fetched once and
+    # kept on this object. Treat the result like the SIP password.
+    def fetch_token_material(opts = {})
+      @fetch_token_material ||= begin
+        resp, opts = request(:get, "#{resource_url}/token_material", {}, opts)
+        Util.convert_to_telnyx_object(resp.data[:data] || resp.data, opts)
+      end
+    end
+
     # Additional action to list tags
     def self.tags(params = {}, opts = {})
       opts = Util.normalize_opts(opts)

data/lib/telnyx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Telnyx
-  VERSION = "3.0.5".freeze
+  VERSION = "3.1.0.pre.1".freeze
 end

data/lib/telnyx.rb

@@ -38,6 +38,7 @@ require "telnyx/list_object"
 require "telnyx/api_resource"
 require "telnyx/singleton_api_resource"
 require "telnyx/webhook"
+require "telnyx/access_token"
 
 require "telnyx/address"
 require "telnyx/alphanumeric_sender_id"

data/telnyx.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
   s.add_dependency("faraday", ">= 2.5.0")
   s.add_dependency("faraday-multipart", "~> 1.0.4")
   s.add_dependency("faraday-net_http_persistent", "~> 2.1.0")
+  s.add_dependency("faraday-retry", "~> 2.0")
   s.add_dependency("net-http-persistent", ">= 3.0", "< 5.0")
   s.add_dependency("ed25519", "~> 1")
 

data/test/telnyx/access_token_test.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Telnyx
+  class AccessTokenTest < Test::Unit::TestCase
+    SECRET = Base64.urlsafe_encode64(OpenSSL::Random.random_bytes(32), padding: false)
+    MATERIAL = {
+      kid: "v1",
+      tel_token: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+      signing_secret: SECRET,
+    }.freeze
+
+    def token(**overrides)
+      AccessToken.new(
+        **{
+          credential_id: "c90a3e6d-8c8c-4c5a-a8b1-6b8d0f2f8a31",
+          user_id: "191d61ea-1cb5-445a-8dd1-384f45e7cb7a",
+          identity: "gencred1234",
+          expires_at: "2027-01-01T00:00:00Z",
+          token_material: MATERIAL,
+        }.merge(overrides)
+      )
+    end
+
+    should "mint a three part HS256 JWT with the Telnyx content type" do
+      jwt = token.to_jwt
+      head, body, sig = jwt.split(".")
+      assert_equal 3, jwt.split(".").size
+      assert_nil jwt[%r{[+/=]}], "token must be base64url without padding"
+
+      header = JSON.parse(Base64.urlsafe_decode64(head))
+      assert_equal({ "alg" => "HS256", "typ" => "JWT", "cty" => "telnyx-webrtc;v=1", "kid" => "v1" }, header)
+
+      expected = OpenSSL::HMAC.digest("SHA256", Base64.urlsafe_decode64(SECRET), "#{head}.#{body}")
+      assert_equal Base64.urlsafe_encode64(expected, padding: false), sig
+    end
+
+    should "carry the credential and the tel_token in the claims" do
+      now = Time.at(1_760_000_000)
+      claims = AccessToken.decode(token.to_jwt(now: now), signing_secret: SECRET)
+
+      assert_equal "c90a3e6d-8c8c-4c5a-a8b1-6b8d0f2f8a31", claims["sub"]
+      assert_equal "191d61ea-1cb5-445a-8dd1-384f45e7cb7a", claims["user_id"]
+      assert_equal "gencred1234", claims["identity"]
+      assert_equal "2027-01-01T00:00:00Z", claims["cred_exp"]
+      assert_equal MATERIAL[:tel_token], claims["tel_token"]
+      assert_equal now.to_i, claims["iat"]
+      assert_equal now.to_i, claims["nbf"]
+      assert_equal now.to_i + 3600, claims["exp"]
+      assert_equal "c90a3e6d-8c8c-4c5a-a8b1-6b8d0f2f8a31-#{now.to_i}", claims["jti"]
+      assert_kind_of Integer, claims["exp"]
+    end
+
+    should "default to one hour and cap the ttl at 24 hours" do
+      now = Time.at(1_760_000_000)
+      assert_equal now.to_i + 3600, AccessToken.decode(token.to_jwt(now: now), signing_secret: SECRET)["exp"]
+      assert_equal now.to_i + 600, AccessToken.decode(token(ttl: 600).to_jwt(now: now), signing_secret: SECRET)["exp"]
+      assert_equal now.to_i + 86_400, AccessToken.decode(token(ttl: 10**6).to_jwt(now: now), signing_secret: SECRET)["exp"]
+      assert_equal now.to_i + 1, AccessToken.decode(token(ttl: 0).to_jwt(now: now), signing_secret: SECRET)["exp"]
+    end
+
+    should "accept token_material with string keys or as a TelnyxObject" do
+      strings = MATERIAL.transform_keys(&:to_s)
+      object = TelnyxObject.construct_from(MATERIAL)
+      a = token(token_material: strings).to_jwt(now: Time.at(0))
+      b = token(token_material: object).to_jwt(now: Time.at(0))
+      assert_equal a, b
+    end
+
+    should "refuse to mint without the material or the identity" do
+      assert_raise(ArgumentError) { token(token_material: nil) }
+      assert_raise(ArgumentError) { token(token_material: MATERIAL.reject { |k, _| k == :signing_secret }) }
+      assert_raise(ArgumentError) { token(token_material: MATERIAL.merge(tel_token: "")) }
+      assert_raise(ArgumentError) { token(identity: nil) }
+      assert_raise(ArgumentError) { token(user_id: "") }
+    end
+
+    should "decode rejects a token signed with another secret" do
+      other = Base64.urlsafe_encode64(OpenSSL::Random.random_bytes(32), padding: false)
+      jwt = token.to_jwt
+      assert_raise(SignatureVerificationError) { AccessToken.decode(jwt, signing_secret: other) }
+
+      tampered = jwt.sub(/\.[^.]+\./, ".#{Base64.urlsafe_encode64('{"sub":"x"}', padding: false)}.")
+      assert_raise(SignatureVerificationError) { AccessToken.decode(tampered, signing_secret: SECRET) }
+    end
+  end
+end

data/test/telnyx/param_wrapper_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Telnyx
+  class ParamWrapperTest < Test::Unit::TestCase
+    class TestResource < APIResource
+      extend Telnyx::APIOperations::List
+      extend Telnyx::APIOperations::ParamWrapper
+      wrap "list", "filter"
+      
+      OBJECT_NAME = "test_resource"
+      
+      # Override request to avoid actual API calls
+      def self.request(method, url, params = {}, opts = {})
+        # Store the parameters for verification
+        @@last_request_params = params
+        
+        # Return a mock response
+        resp = Struct.new(:data).new({ data: [] })
+        [resp, {}]
+      end
+      
+      # Method to retrieve the last request parameters
+      def self.last_request_params
+        @@last_request_params
+      end
+    end
+    
+    context ".list" do
+      should "correctly handle parameters when filter is explicitly provided" do
+        params = {
+          filter: {
+            country_code: "US",
+            limit: 1,
+            phone_number: { starts_with: "123" }
+          }
+        }
+        
+        TestResource.list(params)
+        
+        # Verify the parameters were passed correctly - note that keys may be strings or symbols
+        params = TestResource.last_request_params
+        
+        # Convert all keys to symbols for consistent comparison
+        params_with_symbol_keys = {}
+        params.each do |k, v|
+          params_with_symbol_keys[k.to_sym] = v
+        end
+        
+        assert_equal(
+          { filter: { country_code: "US", limit: 1, phone_number: { starts_with: "123" } } },
+          params_with_symbol_keys
+        )
+      end
+      
+      should "correctly wrap parameters when filter is not explicitly provided" do
+        params = {
+          country_code: "US",
+          limit: 1,
+          phone_number: { starts_with: "123" }
+        }
+        
+        TestResource.list(params)
+        
+        # Verify the parameters were wrapped correctly - note that keys may be strings or symbols
+        params = TestResource.last_request_params
+        
+        # Convert all keys to symbols for consistent comparison
+        params_with_symbol_keys = {}
+        params.each do |k, v|
+          params_with_symbol_keys[k.to_sym] = v
+        end
+        
+        assert_equal(
+          { filter: { country_code: "US", limit: 1, phone_number: { starts_with: "123" } } },
+          params_with_symbol_keys
+        )
+      end
+    end
+  end
+end

data/test/telnyx/telephony_credential_test.rb

@@ -61,6 +61,65 @@ module Telnyx
         assert_requested :get, "#{Telnyx.api_base}/v2/telephony_credentials/tags"
       end
     end
+
+    CREDENTIAL = {
+      record_type: "credential",
+      id: "c90a3e6d-8c8c-4c5a-a8b1-6b8d0f2f8a31",
+      user_id: "191d61ea-1cb5-445a-8dd1-384f45e7cb7a",
+      sip_username: "gencred1234",
+      sip_password: "secret",
+      expires_at: "2027-01-01T00:00:00Z",
+    }.freeze
+    MATERIAL = {
+      kid: "v1",
+      tel_token: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+      signing_secret: Base64.urlsafe_encode64("k" * 32, padding: false),
+    }.freeze
+    URL = "#{PROXY_BASE_URL}/v2/telephony_credentials/#{CREDENTIAL[:id]}".freeze
+
+    context "local token minting" do
+      should "mint from the create response without another request" do
+        stub_request(:post, "#{PROXY_BASE_URL}/v2/telephony_credentials")
+          .to_return(body: JSON.generate(data: CREDENTIAL.merge(token_material: MATERIAL)))
+
+        credential = TelephonyCredential.create(connection_id: "1234567890")
+        jwt = credential.to_jwt(ttl: 600)
+
+        claims = AccessToken.decode(jwt, signing_secret: MATERIAL[:signing_secret])
+        assert_equal CREDENTIAL[:id], claims["sub"]
+        assert_equal CREDENTIAL[:sip_username], claims["identity"]
+        assert_equal MATERIAL[:tel_token], claims["tel_token"]
+        assert_equal claims["iat"] + 600, claims["exp"]
+        assert_not_requested :get, "#{URL}/token_material"
+      end
+
+      should "fetch token_material once for a retrieved credential" do
+        stub_request(:get, URL).to_return(body: JSON.generate(data: CREDENTIAL))
+        stub_request(:get, "#{URL}/token_material").to_return(body: JSON.generate(data: MATERIAL))
+
+        credential = TelephonyCredential.retrieve(CREDENTIAL[:id])
+        first = credential.to_jwt(ttl: 60)
+        second = credential.to_jwt(ttl: 60)
+
+        assert_requested :get, "#{URL}/token_material", times: 1
+        assert_equal MATERIAL[:kid], credential.fetch_token_material[:kid]
+        %w[sub user_id identity tel_token].each do |claim|
+          assert_equal AccessToken.decode(first, signing_secret: MATERIAL[:signing_secret])[claim],
+                       AccessToken.decode(second, signing_secret: MATERIAL[:signing_secret])[claim]
+        end
+      end
+
+      should "mint from material the caller stored, with no request at all" do
+        stub_request(:get, URL).to_return(body: JSON.generate(data: CREDENTIAL))
+        credential = TelephonyCredential.retrieve(CREDENTIAL[:id])
+
+        jwt = credential.to_jwt(token_material: MATERIAL.transform_keys(&:to_s))
+
+        assert_not_requested :get, "#{URL}/token_material"
+        assert_equal CREDENTIAL[:user_id], AccessToken.decode(jwt, signing_secret: MATERIAL[:signing_secret])["user_id"]
+      end
+    end
+
     # Issue with response(RESPONSE SCHEMA: text/plain)
     # should "create telephony credential token" do
     #   telephony_credential = TelephonyCredential.retrieve("id")

data/test/test_params.rb

@@ -0,0 +1,51 @@
+require 'bundler/setup'
+require 'telnyx'
+
+# Set a dummy API key
+Telnyx.api_key = 'TEST_API_KEY'
+
+# Monkey patch the request method to capture parameters without making API calls
+module Telnyx
+  module APIOperations
+    module Request
+      module ClassMethods
+        alias original_request request
+        
+        def request(method, url, params = {}, opts = {})
+          puts "Method: #{method}"
+          puts "URL: #{url}"
+          puts "Raw params: #{params.inspect}"
+          
+          if method.to_s.downcase.to_sym == :get
+            puts "URL-encoded params: #{Telnyx::Util.encode_parameters(params)}"
+          else
+            puts "JSON body: #{JSON.generate(params)}"
+          end
+          
+          # Return a mock response
+          mock_response = Struct.new(:data).new({data: []})
+          [mock_response, {}]
+        end
+      end
+    end
+  end
+end
+
+# Test with the parameters from the example
+puts "\n=== Testing with filter hash ==="
+response = Telnyx::AvailablePhoneNumber.list(
+  filter: {
+    country_code: "US",
+    limit: 1,
+    national_destination_code: "206",
+    phone_number: { starts_with: "4532888" }
+  }
+)
+
+puts "\n=== Testing with direct parameters ==="
+response = Telnyx::AvailablePhoneNumber.list(
+  country_code: "US",
+  limit: 1,
+  national_destination_code: "206",
+  phone_number: { starts_with: "4532888" }
+)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: telnyx
 version: !ruby/object:Gem::Version
-  version: 3.0.5
+  version: 3.1.0.pre.1
 platform: ruby
 authors:
 - Telnyx
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-18 00:00:00.000000000 Z
+date: 2026-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
@@ -90,13 +104,14 @@ description: Telnyx enables anyone to deliver enterprise-grade real-time communi
   over the internet. See https://telnyx.com for details.
 email: support@telnyx.com
 executables:
+- publish-gem
 - telnyx-console
 extensions: []
 extra_rdoc_files: []
 files:
 - ".github/ISSUE_TEMPLATE.md"
 - ".github/scripts/before_install.sh"
-- ".github/workflows/publish-gem-on-release.yml"
+- ".github/workflows/publish-gem.yml"
 - ".github/workflows/ruby.yml"
 - ".github/workflows/tweet-release.yml"
 - ".gitignore"
@@ -112,6 +127,7 @@ files:
 - Rakefile
 - Spec3.json
 - VERSION
+- bin/publish-gem
 - bin/telnyx-console
 - examples/fax/Gemfile
 - examples/fax/config.yaml
@@ -121,6 +137,7 @@ files:
 - lib/telnyx.rb
 - lib/telnyx/access_control_ip.rb
 - lib/telnyx/access_ip_range.rb
+- lib/telnyx/access_token.rb
 - lib/telnyx/address.rb
 - lib/telnyx/alphanumeric_sender_id.rb
 - lib/telnyx/api_operations/create.rb
@@ -261,6 +278,7 @@ files:
 - telnyx.gemspec
 - test/api_stub_helpers.rb
 - test/openapi/README.md
+- test/telnyx/access_token_test.rb
 - test/telnyx/address_test.rb
 - test/telnyx/alphanumeric_sender_id_test.rb
 - test/telnyx/api_operations_test.rb
@@ -326,6 +344,7 @@ files:
 - test/telnyx/number_reservation_test.rb
 - test/telnyx/ota_update_test.rb
 - test/telnyx/outbound_voice_profile_test.rb
+- test/telnyx/param_wrapper_test.rb
 - test/telnyx/phone_number_block_job_test.rb
 - test/telnyx/phone_number_regulatory_requirement_test.rb
 - test/telnyx/phone_number_test.rb
@@ -370,6 +389,7 @@ files:
 - test/telnyx_test.rb
 - test/test_data.rb
 - test/test_helper.rb
+- test/test_params.rb
 homepage: https://developers.telnyx.com
 licenses:
 - MIT
@@ -378,7 +398,7 @@ metadata:
   github_repo: ssh://github.com/team-telnyx/telnyx-ruby
   homepage_uri: https://telnyx.com
   source_code_uri: https://github.com/team-telnyx/telnyx-ruby
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -389,17 +409,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.2.15
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Ruby bindings for the Telnyx API
 test_files:
 - test/api_stub_helpers.rb
 - test/openapi/README.md
+- test/telnyx/access_token_test.rb
 - test/telnyx/address_test.rb
 - test/telnyx/alphanumeric_sender_id_test.rb
 - test/telnyx/api_operations_test.rb
@@ -465,6 +486,7 @@ test_files:
 - test/telnyx/number_reservation_test.rb
 - test/telnyx/ota_update_test.rb
 - test/telnyx/outbound_voice_profile_test.rb
+- test/telnyx/param_wrapper_test.rb
 - test/telnyx/phone_number_block_job_test.rb
 - test/telnyx/phone_number_regulatory_requirement_test.rb
 - test/telnyx/phone_number_test.rb
@@ -509,3 +531,4 @@ test_files:
 - test/telnyx_test.rb
 - test/test_data.rb
 - test/test_helper.rb
+- test/test_params.rb

data/.github/workflows/publish-gem-on-release.yml

@@ -1,53 +0,0 @@
-on:
-  release:
-    types: [released]
-
-jobs:
-  #Deprecating, incoming replacement for self-hosted mock service
-  #test:
-    #env:
-    #  TELNYX_MOCK_OPEN_API_URI: https://raw.githubusercontent.com/team-telnyx/openapi/master/openapi/spec3.json
-    #runs-on: ubuntu-latest
-    #strategy:
-    #  matrix:
-    #    ruby: [ '3.0', '3.1', '3.2' ]
-    #steps:
-    #- uses: actions/checkout@v4
-    #- name: Set up Ruby
-    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
-    # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-    # uses: ruby/setup-ruby@v1
-    #  with:
-    #    ruby-version: ${{ matrix.ruby }}
-    #- name: Run Setup Script to install prism mock
-    #  run: source ./.github/scripts/before_install.sh
-    #  shell: bash
-    #- name: Install dependencies
-    #  run: bundle install
-    #- name: Run tests
-    #  run: bundle exec rake
-
-  build_and_publish_gem:
-    name: Build + Publish Gem
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Ruby 3.0
-        uses: ruby/setup-ruby@477b21f02be01bcb8030d50f37cfec92bfa615b6
-        with:
-          ruby-version: 3.0
-      - run: bundle install
-      - name: Publish to RubyGems
-        run: |
-          mkdir -p $HOME/.gem
-          touch $HOME/.gem/credentials
-          chmod 0600 $HOME/.gem/credentials
-          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-          gem build *.gemspec
-          gem push *.gem
-        env:
-          GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_API_KEY}}"