panda_pal 5.18.2 → 5.19.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb0e4fb14c2e0d6b9e35ec6dd8e865c428d903ecea13870eaaf573c3799af975
-  data.tar.gz: 93e7c30bd6501db96b4a5cadd4b5d412b67992f292d39959496f3962c38f0963
+  metadata.gz: b8433b20262277ab9a0e66156b4fb2b865919cbfe73701202c163b1dd4c063c9
+  data.tar.gz: fba4d18d40156ccf1799c33b4b2a5aed33b71c6e0e772a65df04c586f207503f
 SHA512:
-  metadata.gz: 4ed68a456f64341cd6627e08f6b24b7936e75b39b077d2d458695db7e7be58ddd723cfcf44b095001c411b66993971b042a33d8bc62f7f2aa07d95e36773568d
-  data.tar.gz: '08ccb27dd49356d5a51d020cd93cb86626ef1f108b99fcc75f38cd2a147fbc28859570cdd7dbafe7ef37d74b7ca08aa0a09793bc3d6b6e1ebac5c64158aec9aa'
+  metadata.gz: 33e70423978afce311e1e0d4a5eecddc17e8814e922bea12e854b1b57135cc336e1c418b6f8d0fcca061c4a25485164dab1468805639d16abd6f1c1951f7b4cb
+  data.tar.gz: fa08843f3ad5d268203908c22725c546825102127cce6858c907a84b21e0a58561fab5f1e017b569cb95abd5e42c1715045b699b7790f899e7bbabfbf8f9693c

data/README.md

@@ -30,9 +30,48 @@ org.install_lti(
   exists: :error, # (Optional) Action to take if an LTI with the same Key already exists. Options are :error, :replace, :duplicate, :update
   version: "v1p3", # (Optional, default `v1p3`) LTI Version. Accepts `v1p0` or `v1p3`.
   dedicated_deployment: false, # (Optional) If true, the Organization will be updated to link to a single deployment rather then to the general LTI Key. (experimental, LTI 1.3 only)
+  tool: :default, # (Optional) Which tool to install - see Multiple Tools below
 )
 ```
 
+### Multiple Tools
+One app can publish more than one LTI tool - for example a teacher-facing tool and a separate, student-facing editor button with its own label and visibility. In Canvas each tool is its own Developer Key (LTI 1.3) or its own External Tool (LTI 1.0), with its own placements.
+
+Everything configured without a `tool:` belongs to the default tool, so single-tool apps don't change.
+
+```ruby
+# config/initializers/lti.rb
+PandaPal.define_tool(:translate,
+  title: 'Teacher Reports - Translate', # Merged over lti_options for this tool's config
+  custom_params: { mode: 'translate' }, # Merged over lti_custom_params for this tool's config
+)
+
+PandaPal.stage_placement(:editor_button, tool: :translate, text: 'Translate', visibility: 'public')
+```
+
+```ruby
+# config/routes.rb
+lti_nav editor_button: 'translate#editor_button', tool: :translate # Served at <mount>/translate/editor_button
+```
+
+- **Config:** each tool has its own config URL: `/v1p3/config?tool=translate` and `/v1p0/config?tool=translate`. The default tool's URLs are unchanged.
+- **Install:** `org.install_lti(host: ..., tool: :translate)`. On LTI 1.3 this creates (or reuses) the tool's own Developer Key and records it as a `PandaPal::LtiRegistration` on the Organization. The Organization's `key` keeps pointing at the default tool. On LTI 1.0 both tools share the Organization's consumer key and secret.
+- **Install hooks:** `before_lti_install` / `after_lti_install` callbacks can read `current_lti_install` (`tool`, `host`, `context`, `version`, `exists`, `dedicated_deployment`, and, in `after_lti_install`, the resulting Canvas `installation`). That lets you install a second tool alongside the default one:
+  ```ruby
+  # app/models/organization_extension.rb
+  included do
+    after_lti_install :install_translate_tool
+  end
+
+  def install_translate_tool
+    install = current_lti_install
+    return unless install.tool == PandaPal::DEFAULT_TOOL # the nested :translate install runs these callbacks too
+    install_lti(**install.to_h.except(:installation), tool: :translate)
+  end
+  ```
+- **Launches:** `current_session.lti_tool` says which tool was launched. On LTI 1.3 the tool comes from the registration matching the launch's client ID (and deployment ID). On LTI 1.0 it comes from the signed `custom_panda_pal_tool` field that every non-default tool config includes. PandaPal routes each launch, and each deep-link redirect, using that tool's placements.
+- **Registering by hand:** if a tool's Developer Key was set up outside `install_lti`, register it yourself: `org.lti_registrations.create!(tool: 'translate', client_id: '10000000000123', deployment_id: nil)`. A registration with a `deployment_id` takes priority over one without.
+
 ### LTI 1.3 Configuration
 LTI 1.3 has some additional configuration steps required to setup an LTI:
 

data/app/controllers/panda_pal/lti_v1_p0_controller.rb

@@ -18,7 +18,7 @@ module PandaPal
         launch_params: request.request_parameters.to_h,
       })
 
-      redirect_with_session_to(:"#{LaunchUrlHelpers.launch_route(params[:launch_type])}_url", route_context: main_app)
+      redirect_with_session_to(:"#{current_session.lti_launch_route(params[:launch_type])}_url", route_context: main_app)
     end
 
     def tool_config
@@ -26,13 +26,20 @@ module PandaPal
         render plain: 'Domains must be set in lti_environments'
         return
       end
-      platform = PandaPal.lti_options.delete(:platform) || 'canvas.instructure.com'
+
+      unless PandaPal.lti_tool?(params[:tool])
+        render plain: "Unknown LTI tool '#{params[:tool]}'", status: :not_found
+        return
+      end
+
+      tool = PandaPal.normalize_lti_tool!(params[:tool])
+      platform = PandaPal.lti_tool_options(tool).delete(:platform) || 'canvas.instructure.com'
       request_url = "#{request.scheme}://#{request.host_with_port}"
       case platform
       when 'canvas.instructure.com'
-        xml_config = LtiXml::CanvasPlatform.new(platform, request_url, main_app)
+        xml_config = LtiXml::CanvasPlatform.new(platform, request_url, main_app, tool: tool)
       when 'bridgeapp.com'
-        xml_config = LtiXml::BridgePlatform.new(platform, request_url, main_app)
+        xml_config = LtiXml::BridgePlatform.new(platform, request_url, main_app, tool: tool)
       else
         render plain: 'platform must be set under lti_options'
         return

data/app/controllers/panda_pal/lti_v1_p3_controller.rb

@@ -50,7 +50,7 @@ module PandaPal
           launch_params: @decoded_lti_jwt,
         })
 
-        redirect_with_session_to(:"#{LaunchUrlHelpers.launch_route(ltype)}_url", route_context: main_app)
+        redirect_with_session_to(:"#{current_session.lti_launch_route(ltype)}_url", route_context: main_app)
       end
     end
 
@@ -72,7 +72,7 @@ module PandaPal
         deep_link_data: @decoded_lti_jwt[LtiConstants::DeepLinking::DATA]
       })
 
-      redirect_url = LaunchUrlHelpers.deep_link_redirect_url(request)
+      redirect_url = current_session.deep_link_redirect_url(request)
       if redirect_url
         redirect_with_session_to(redirect_url, route_context: main_app)
       else
@@ -86,28 +86,37 @@ module PandaPal
         return
       end
 
-      platform = PandaPal.lti_options.delete(:platform) || 'canvas.instructure.com'
+      unless PandaPal.lti_tool?(params[:tool])
+        render plain: "Unknown LTI tool '#{params[:tool]}'", status: :not_found
+        return
+      end
+
+      tool = PandaPal.normalize_lti_tool!(params[:tool])
+      tool_options = PandaPal.lti_tool_options(tool)
+
+      platform = tool_options.delete(:platform) || 'canvas.instructure.com'
       request_url = "#{request.scheme}://#{request.host_with_port}"
       parsed_request_url = URI.parse(request_url)
 
-      mapped_placements = PandaPal.lti_paths.map do |k, opts|
+      mapped_placements = PandaPal.lti_paths(tool).map do |k, opts|
         opts = LaunchUrlHelpers.normalize_lti_launch_desc(opts)
         opts.merge!({
           placement: k,
           target_link_uri: LaunchUrlHelpers.absolute_launch_url(
             k.to_sym,
             host: parsed_request_url,
-            default_auto_launch: true
+            default_auto_launch: true,
+            tool: tool
           ),
         })
         opts
       end
 
       config_json = {
-        title: PandaPal.lti_options[:title],
+        title: tool_options[:title],
         scopes: PandaPal.lti_scopes,
         public_jwk_url: v1p3_public_jwks_url,
-        description: PandaPal.lti_options[:description] || 'PandaPal LTI',
+        description: tool_options[:description] || 'PandaPal LTI',
         target_link_uri: v1p3_resource_link_request_url, #app_url(:resource_link_request, request),
         oidc_initiation_url: v1p3_oidc_login_url,
         extensions: [{
@@ -117,7 +126,7 @@ module PandaPal
             placements: mapped_placements,
           },
         }],
-        custom_fields: PandaPal.lti_custom_params, # PandaPal.lti_options[:custom_fields],
+        custom_fields: PandaPal.lti_custom_params(tool), # PandaPal.lti_options[:custom_fields],
       }
 
       render json: config_json

data/app/lib/lti_xml/base_platform.rb

@@ -1,11 +1,12 @@
 module LtiXml
   class BasePlatform
-    attr_accessor :parsed_request_url, :platform, :main_app
+    attr_accessor :parsed_request_url, :platform, :main_app, :tool
 
-    def initialize(platform, full_request_url, main_app)
+    def initialize(platform, full_request_url, main_app, tool: PandaPal::DEFAULT_TOOL)
       @platform = platform
       @parsed_request_url = URI.parse(full_request_url)
       @main_app = main_app
+      @tool = tool
     end
 
     # Override one of the following formatter methods in your individual platform class, or if you must, you can override
@@ -22,7 +23,7 @@ module LtiXml
 
       #strip the launch url
       xml = @tc.to_xml
-      xml = xml.sub(/<blti:launch_url>.*<\/blti:launch_url>/, '') if PandaPal.lti_options[:launch_url] === false
+      xml = xml.sub(/<blti:launch_url>.*<\/blti:launch_url>/, '') if lti_options[:launch_url] === false
 
       return xml
     end
@@ -30,15 +31,15 @@ module LtiXml
     private
 
     def ims_tool_config
-      ims_lti_config = {title: PandaPal.lti_options[:title]}
-      if PandaPal.lti_options[:secure_launch_url].present? # Assumes full URL is provided
-        ims_lti_config[:secure_launch_url] = PandaPal.lti_options[:secure_launch_url]
-      elsif PandaPal.lti_options[:secure_launch_path].present? # Assumes path is provided
-        ims_lti_config[:secure_launch_url] = "#{lti_domain_from_url}#{PandaPal.lti_options[:secure_launch_path]}"
-      elsif PandaPal.lti_options[:launch_url].present? # Assumes full URL is provided
-        ims_lti_config[:launch_url] = PandaPal.lti_options[:launch_url]
-      elsif PandaPal.lti_options[:launch_path].present? # Assumes path is provided
-        ims_lti_config[:launch_url] = "#{lti_domain_from_url}#{PandaPal.lti_options[:launch_path]}"
+      ims_lti_config = {title: lti_options[:title]}
+      if lti_options[:secure_launch_url].present? # Assumes full URL is provided
+        ims_lti_config[:secure_launch_url] = lti_options[:secure_launch_url]
+      elsif lti_options[:secure_launch_path].present? # Assumes path is provided
+        ims_lti_config[:secure_launch_url] = "#{lti_domain_from_url}#{lti_options[:secure_launch_path]}"
+      elsif lti_options[:launch_url].present? # Assumes full URL is provided
+        ims_lti_config[:launch_url] = lti_options[:launch_url]
+      elsif lti_options[:launch_path].present? # Assumes path is provided
+        ims_lti_config[:launch_url] = "#{lti_domain_from_url}#{lti_options[:launch_path]}"
       else
         ims_lti_config[:launch_url] = lti_domain_from_url
       end
@@ -67,22 +68,22 @@ module LtiXml
     end
 
     def add_lti_custom_params
-      PandaPal.lti_custom_params.each do |k, v|
+      lti_custom_params.each do |k, v|
         @tc.set_custom_param k, v
       end
     end
 
     def add_lti_options
-      if PandaPal.lti_options.has_key?(:custom_fields)
-        @tc.set_ext_param(platform, :custom_fields, PandaPal.lti_options[:custom_fields])
-        PandaPal.lti_options[:custom_fields].each do |k, v|
+      if lti_options.has_key?(:custom_fields)
+        @tc.set_ext_param(platform, :custom_fields, lti_options[:custom_fields])
+        lti_options[:custom_fields].each do |k, v|
           @tc.set_ext_param(platform, k, v)
         end
       end
     end
 
     def add_lti_nav
-      PandaPal.lti_paths.each do |k, v|
+      lti_paths.each do |k, v|
         @tc.set_ext_param(platform, k.to_sym, ext_params(v, k))
       end
     end
@@ -97,9 +98,22 @@ module LtiXml
         k.to_sym,
         host: parsed_request_url,
         launch_handler: :v1p0_launch_path,
-        default_auto_launch: false
+        default_auto_launch: false,
+        tool: tool
       )
       options
     end
+
+    def lti_options
+      PandaPal.lti_tool_options(tool)
+    end
+
+    def lti_custom_params
+      PandaPal.lti_custom_params(tool)
+    end
+
+    def lti_paths
+      PandaPal.lti_paths(tool)
+    end
   end
 end

data/app/lib/lti_xml/bridge_platform.rb

@@ -1,8 +1,8 @@
 module LtiXml
   class BridgePlatform < BasePlatform
     def add_lti_custom_params
-      if PandaPal.lti_custom_params.any?
-        @tc.set_ext_param(platform, :custom_fields, PandaPal.lti_custom_params)
+      if lti_custom_params.any?
+        @tc.set_ext_param(platform, :custom_fields, lti_custom_params)
       end
     end
   end

data/app/lib/panda_pal/launch_url_helpers.rb

@@ -1,7 +1,7 @@
 module PandaPal
   module LaunchUrlHelpers
-    def self.absolute_launch_url(launch_type, host: uri_host, launch_handler: nil, default_auto_launch: false)
-      opts = PandaPal.lti_paths[launch_type]
+    def self.absolute_launch_url(launch_type, host: uri_host, launch_handler: nil, default_auto_launch: false, tool: PandaPal::DEFAULT_TOOL)
+      opts = PandaPal.lti_paths(tool)[launch_type]
 
       if launch_handler.nil? && opts.present?
         launch_handler = opts[:message_type] == PandaPal::LtiConstants::MessageTypes::DEEP_LINKING_REQUEST ?
@@ -18,7 +18,7 @@ module PandaPal
           launch_type: launch_type,
         })
       else
-        final_url = launch_url(opts, launch_type: launch_type)
+        final_url = launch_url(opts, launch_type: launch_type, tool: tool)
         return final_url if URI.parse(final_url).absolute?
         return [host.to_s, final_url].join
       end
@@ -43,16 +43,16 @@ module PandaPal
       opts
     end
 
-    def self.launch_url(opts, launch_type: nil)
-      url = launch_route(opts, launch_type: launch_type)
+    def self.launch_url(opts, launch_type: nil, tool: PandaPal::DEFAULT_TOOL)
+      url = launch_route(opts, launch_type: launch_type, tool: tool)
       url = resolve_url_symbol(url) if url.is_a?(Symbol)
       url
     end
 
-    def self.launch_route(opts, launch_type: nil)
+    def self.launch_route(opts, launch_type: nil, tool: PandaPal::DEFAULT_TOOL)
       if opts.is_a?(Symbol) || opts.is_a?(String)
         launch_type = opts.to_sym
-        opts = PandaPal.lti_paths[launch_type] || {}
+        opts = PandaPal.lti_paths(tool)[launch_type] || {}
       end
 
       if opts[:route_helper_key]
@@ -79,6 +79,13 @@ module PandaPal
       uri.to_s
     end
 
+    # Query params selecting a tool's config (/v1p0/config, /v1p3/config) - none for
+    # the default tool, so its config URLs stay exactly as they've always been.
+    def self.tool_config_params(tool)
+      tool = PandaPal.normalize_lti_tool!(tool)
+      tool == PandaPal::DEFAULT_TOOL ? {} : { tool: tool.to_s }
+    end
+
     def self.with_uri_host(uri)
       uri = URI.parse(uri) unless uri.is_a?(URI)
       raise "host: param must have a protocal and no path" if uri.path.present?
@@ -108,24 +115,24 @@ module PandaPal
       engine.routes.url_helpers.send(key_bits[1], *arguments, **kwargs)
     end
 
-    def self.deep_link_redirect_url(request)
+    def self.deep_link_redirect_url(request, tool: PandaPal::DEFAULT_TOOL)
       # Try placement-specific configuration first
       launch_type = request.query_parameters['launch_type']&.to_sym
-      return global_configuration_url unless launch_type
+      return global_configuration_url(tool: tool) unless launch_type
 
-      placement_config = PandaPal.lti_paths[launch_type]
-      return global_configuration_url unless deep_linking_placement?(placement_config)
+      placement_config = PandaPal.lti_paths(tool)[launch_type]
+      return global_configuration_url(tool: tool) unless deep_linking_placement?(placement_config)
 
       # Check for explicit deep_link_redirect_url configuration
       redirect_url = placement_config[:deep_link_redirect_url]
       return normalize_redirect_url(redirect_url) if redirect_url.present?
 
       # Fall back to global configuration
-      global_configuration_url
+      global_configuration_url(tool: tool)
     end
 
-    def self.global_configuration_url
-      redirect_url = PandaPal.lti_options[:deep_link_redirect_url]
+    def self.global_configuration_url(tool: PandaPal::DEFAULT_TOOL)
+      redirect_url = PandaPal.lti_tool_options(tool)[:deep_link_redirect_url]
       normalize_redirect_url(redirect_url) if redirect_url.present?
     end
 

data/app/models/panda_pal/lti_registration.rb

@@ -0,0 +1,41 @@
+module PandaPal
+  # Maps an LTI 1.3 client_id (Developer Key), and optionally one deployment of
+  # it, to an Organization and to the PandaPal tool it serves.
+  #
+  # The Organization's own `key` still identifies its default tool. A
+  # registration is what lets one Organization be reached through more than one
+  # Developer Key (one per tool - see PandaPal.define_tool), or through
+  # additional deployments of a key.
+  class LtiRegistration < PandaPalRecord
+    belongs_to :panda_pal_organization, class_name: 'PandaPal::Organization'
+
+    validates :tool, presence: true
+    validates :client_id, presence: true
+    validates :deployment_id, uniqueness: { scope: :client_id }
+    validate :tool_is_defined
+
+    before_validation do
+      self.client_id = client_id.to_s if client_id.present?
+      self.deployment_id = deployment_id.presence&.to_s
+    end
+
+    # A deployment-specific registration wins over one that covers the whole key.
+    def self.for_launch(client_id, deployment_id)
+      return nil if client_id.blank?
+
+      scope = where(client_id: client_id.to_s)
+      registration = scope.find_by(deployment_id: deployment_id.to_s) if deployment_id.present?
+      registration || scope.find_by(deployment_id: nil)
+    end
+
+    def lti_tool
+      tool.to_sym
+    end
+
+    private
+
+    def tool_is_defined
+      errors.add(:tool, "'#{tool}' is not a defined PandaPal tool") if tool.present? && !PandaPal.lti_tool?(tool)
+    end
+  end
+end

data/app/models/panda_pal/organization.rb

@@ -53,6 +53,8 @@ module PandaPal
       self.settings_panda_pal_super = settings
     end
 
+    has_many :lti_registrations, class_name: 'PandaPal::LtiRegistration', foreign_key: :panda_pal_organization_id, dependent: :destroy
+
     validates :key, uniqueness: { case_sensitive: false }, presence: true
     validates :secret, presence: true
     validates :name, uniqueness: { case_sensitive: false }, presence: true, format: { with: /\A[a-z0-9_]+\z/i }

data/app/models/panda_pal/platform/canvas.rb

@@ -62,10 +62,21 @@ module PandaPal
     module OrgExtension
       extend ActiveSupport::Concern
 
+      # What an install_lti call is installing, for :lti_install callbacks to read
+      # through #current_lti_install. `version` is normalized ('v1p0'/'v1p3').
+      # `installation` is the Canvas external tool, set once the install has run
+      # (so it's there for after_lti_install, not before_lti_install).
+      LtiInstall = Struct.new(:tool, :host, :context, :version, :exists, :dedicated_deployment, :installation, keyword_init: true)
+
       included do
         define_model_callbacks :lti_install
       end
 
+      # The LtiInstall currently running callbacks, or nil outside install_lti.
+      # An install started from inside a callback gets its own LtiInstall, and the
+      # outer one comes back once it's done.
+      attr_reader :current_lti_install
+
       def _parse_lti_context(context)
         context = context.to_s
         context = 'account/self' if context == 'root_account'
@@ -75,41 +86,59 @@ module PandaPal
         [ctype, cid]
       end
 
-      def _install_lti(host: nil, context: :root_account, version: nil, exists: :error, dedicated_deployment: false)
+      # `tool:` installs one of the tools registered with PandaPal.define_tool
+      # instead of the default one. In LTI 1.3 each tool is its own Developer Key,
+      # tracked by an LtiRegistration rather than by this Organization's `key`.
+      def _install_lti(host: nil, context: :root_account, version: nil, exists: :error, dedicated_deployment: false, tool: PandaPal::DEFAULT_TOOL)
+        outer_install = @current_lti_install
         raise "Automatically installing this LTI requires Bearcat." unless defined?(Bearcat)
 
-        version = version || PandaPal.lti_options[:lti_spec_version] || 'v1p3'
+        tool = PandaPal.normalize_lti_tool!(tool)
+        tool_options = PandaPal.lti_tool_options(tool)
+
+        version = version || tool_options[:lti_spec_version] || 'v1p3'
         version = version.to_s
 
         if (vs = version.split(".")).count > 1
-          version = "v#{vs[0]}p#{vs[0]}"
+          version = "v#{vs[0]}p#{vs[1]}"
         end
+        # PandaPal's v1p0 endpoints serve LTI 1.1 as well
+        version = 'v1p0' if version == 'v1p1'
 
         # TODO Ensure host is actually this LTI
 
+        @current_lti_install = LtiInstall.new(
+          tool: tool,
+          host: host,
+          context: context,
+          version: version,
+          exists: exists,
+          dedicated_deployment: dedicated_deployment,
+        )
+
         run_callbacks :lti_install do
           ctype, cid = _parse_lti_context(context)
 
           if version == 'v1p0'
             existing_installs = _find_existing_installs(context, exists: exists) do |lti|
-              lti[:consumer_key] == self.key
+              lti[:consumer_key] == self.key && _installed_lti_tool(lti) == tool
             end
 
             conf = {
-              name: PandaPal.lti_options[:title],
-              description: PandaPal.lti_options[:description],
+              name: tool_options[:title],
+              description: tool_options[:description],
               consumer_key: self.key,
               shared_secret: self.secret,
               privacy_level: "public",
               config_type: 'by_url',
-              config_url: PandaPal::LaunchUrlHelpers.resolve_route(:v1p0_config_url, host: host),
+              config_url: PandaPal::LaunchUrlHelpers.resolve_route(:v1p0_config_url, host: host, **PandaPal::LaunchUrlHelpers.tool_config_params(tool)),
             }
 
             api_result = existing_installs[0] ? bearcat_client.send(:"edit_#{ctype}_external_tool", cid, existing_installs[0][:id], conf) : bearcat_client.send(:"create_#{ctype}_external_tool", cid, conf)
 
             @new_lti_installation = api_result
           elsif version == 'v1p3'
-            ekey = _ensure_lti_v1p3_key(exists: exists, host: host)
+            ekey = _ensure_lti_v1p3_key(exists: exists, host: host, tool: tool)
 
             existing_installs = _find_existing_installs(context, exists: exists) do |lti|
               # TODO This may not be correct when actually inheriting LTI keys
@@ -119,7 +148,17 @@ module PandaPal
             scope_tool = existing_installs[0]
 
             # Don't need to do an update if it already exists - Settings are stored on the LTI Key instead of the installation
-            unless scope_tool
+            if tool != PandaPal::DEFAULT_TOOL
+              scope_tool ||= bearcat_client.send(:"create_#{ctype}_external_tool", cid, {
+                client_id: ekey[:id],
+              })
+
+              lti_registrations.find_or_create_by!(
+                tool: tool.to_s,
+                client_id: ekey[:id].to_s,
+                deployment_id: (scope_tool[:deployment_id].presence&.to_s if dedicated_deployment),
+              )
+            elsif !scope_tool
               scope_tool = bearcat_client.send(:"create_#{ctype}_external_tool", cid, {
                 client_id: ekey[:id],
               })
@@ -137,9 +176,13 @@ module PandaPal
           else
             raise "Unrecognized LTI Version #{version}"
           end
+
+          @current_lti_install.installation = @new_lti_installation
         end
 
         save!
+      ensure
+        @current_lti_install = outer_install
       end
 
       def install_lti(*args, **kwargs)
@@ -148,20 +191,32 @@ module PandaPal
         end
       end
 
-      def _ensure_lti_v1p3_key(exists:, host:)
-        current_client_id = self.key.split('/')[0]
+      def _installed_lti_tool(installed_tool)
+        custom_fields = installed_tool[:custom_fields] || {}
+        name = custom_fields[PandaPal::TOOL_CUSTOM_FIELD] || custom_fields[PandaPal::TOOL_CUSTOM_FIELD.to_sym]
+        name.presence&.to_sym || PandaPal::DEFAULT_TOOL
+      end
 
-        existing_keys = []
-        existing_keys += bearcat_client.get("api/v1/accounts/self/developer_keys?per_page=100").filter do |devkey|
-          devkey[:id].to_s == current_client_id
+      def _ensure_lti_v1p3_key(exists:, host:, tool: PandaPal::DEFAULT_TOOL)
+        current_client_id = if tool == PandaPal::DEFAULT_TOOL
+          self.key.split('/')[0]
+        else
+          lti_registrations.where(tool: tool.to_s).pick(:client_id)
         end
-        existing_keys += bearcat_client.get("api/v1/accounts/self/developer_keys?per_page=100", inherited: true).filter do |devkey|
-          devkey[:id].to_s == current_client_id
+
+        existing_keys = []
+        if current_client_id.present?
+          existing_keys += bearcat_client.get("api/v1/accounts/self/developer_keys?per_page=100").filter do |devkey|
+            devkey[:id].to_s == current_client_id
+          end
+          existing_keys += bearcat_client.get("api/v1/accounts/self/developer_keys?per_page=100", inherited: true).filter do |devkey|
+            devkey[:id].to_s == current_client_id
+          end
         end
 
         ekey = existing_keys[0]
 
-        lti_json_url = PandaPal::LaunchUrlHelpers.resolve_route(:v1p3_config_url, host: host)
+        lti_json_url = PandaPal::LaunchUrlHelpers.resolve_route(:v1p3_config_url, host: host, **PandaPal::LaunchUrlHelpers.tool_config_params(tool))
         lti_json = JSON.parse(HTTParty.get(lti_json_url, format: :plain).body)
 
         valid_redirect_uris = [
@@ -193,7 +248,7 @@ module PandaPal
           # Create New
           ekey = bearcat_client.post("api/lti/accounts/self/developer_keys/tool_configuration", {
             developer_key: {
-              name: PandaPal.lti_options[:title],
+              name: PandaPal.lti_tool_options(tool)[:title],
               redirect_uris: valid_redirect_uris.join("\n"),
             },
             tool_configuration: {
@@ -258,18 +313,21 @@ module PandaPal
         install_lti(*args, exists: :replace, **kwargs)
       end
 
-      def lti_api_configuration(host: nil)
+      def lti_api_configuration(host: nil, tool: PandaPal::DEFAULT_TOOL)
+        tool = PandaPal.normalize_lti_tool!(tool)
+        tool_options = PandaPal.lti_tool_options(tool)
+
         PandaPal::LaunchUrlHelpers.with_uri_host(host) do
           domain = PandaPal.lti_properties[:domain] || host.host
-          launch_url = PandaPal.lti_options[:secure_launch_url] ||
-            "#{domain}#{PandaPal.lti_options[:secure_launch_path]}" ||
-            PandaPal.lti_options[:launch_url] ||
-            "#{domain}#{PandaPal.lti_options[:launch_path]}" ||
+          launch_url = tool_options[:secure_launch_url] ||
+            "#{domain}#{tool_options[:secure_launch_path]}" ||
+            tool_options[:launch_url] ||
+            "#{domain}#{tool_options[:launch_path]}" ||
             domain
 
           lti_json = {
-            name: PandaPal.lti_options[:title],
-            description: PandaPal.lti_options[:description],
+            name: tool_options[:title],
+            description: tool_options[:description],
             domain: host.host,
             url: launch_url,
             consumer_key: self.key,
@@ -284,17 +342,19 @@ module PandaPal
           lti_json = lti_json.with_indifferent_access
           lti_json.merge!(PandaPal.lti_properties)
 
-          (PandaPal.lti_options[:custom_fields] || []).each do |k, v|
+          (tool_options[:custom_fields] || []).each do |k, v|
             lti_json[:custom_fields][k] = v
           end
+          lti_json[:custom_fields][PandaPal::TOOL_CUSTOM_FIELD] = tool.to_s unless tool == PandaPal::DEFAULT_TOOL
 
-          PandaPal.lti_paths.each do |k, options|
+          PandaPal.lti_paths(tool).each do |k, options|
             options = PandaPal::LaunchUrlHelpers.normalize_lti_launch_desc(options)
             options[:url] = PandaPal::LaunchUrlHelpers.absolute_launch_url(
               k.to_sym,
               host: host,
               launch_handler: :v1p0_launch_path,
-              default_auto_launch: false
+              default_auto_launch: false,
+              tool: tool
             ).to_s
             lti_json[k] = options
           end