telnyx 3.0.6 → 3.1.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 119256278a1a98976546bc78f69fbc4f14f08deb8dea0f492833e1e7fc90d5f8
-  data.tar.gz: 64c553ce027e5e14e79d93f635b32d5032aacfcf16c951dc6b8c6dc24f1a3a1c
+  metadata.gz: 84d4e73bfaa1a623aa43940a4f86155b938703fc3d7cf70ffa76b97569c70c35
+  data.tar.gz: e29d1cc3c049e1d38f2b1c49e09f365f55abac868a5684805db0fe6d72294b36
 SHA512:
-  metadata.gz: 789ca83329b14511166e268d8a1549cd4aefb92d297b134df98761ef0b38fcb1877c9727777c827f84a896e1a37138799b647b2d7dcdc3bef951bc6551c207d0
-  data.tar.gz: 9d71107f074a2bd0c8e33f9d1645545a0334931fce33e436bc5e06dc90bdda7bb6c8ec6364eb82f9f0a8de8203a7bee86e201b8b137f4eafbfcd8890e2146795
+  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.6
+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/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.6".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/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")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: telnyx
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 3.1.0.pre.1
 platform: ruby
 authors:
 - Telnyx
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-13 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
@@ -391,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
+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

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}}"