panda_pal 5.18.1 → 5.19.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cfa6473dc16edac94d626e45b19ffba9fad24f213a8696808237685a20a4131
-  data.tar.gz: 9586403513860b1c18ac4203d468fd80ac48b7e13a4749ef7b75992e7b64241d
+  metadata.gz: 36f3440bb369f482a622cca1b58dbe3857bd74749d53776be10e6b99e8bf3f79
+  data.tar.gz: 02c42332159e06ae1778d8155c2a58d230ae24dc82a5f1e0c6027aa7e0a9f274
 SHA512:
-  metadata.gz: 945a38a43d4107b62c3f2d9f2097ebf5345157d7c30fa28afccf177c96f71894b08b84cac3612c0954ebccf73b51425fc2d7c7fefab509578bbb4f83be5ce403
-  data.tar.gz: 6dac2d051c4f718db105efa8b37d43de205c559f05800b07a0d671d983db9426f9831b80aae1cffa408da3fa57feb1aa5c2e39b41c3ff181c801d60f5da0604d
+  metadata.gz: 9d4253dfec794377b88c5efbd6b2167b225373049e0e7b7694ef3f6f4d5e39253e71aa720094b39b336e6b4afc251b00c7f60f35dc1dbe3bb11dde35ce9b966b
+  data.tar.gz: b5004d4d2f7be4dcfb91d70d81445284084ea24a11f03f8db8513c6794cacdef99bf9c4da96c50b51cd1a9870ae4129ca3d66ac6b91a0065f4ef34e1aac59157

data/README.md

@@ -30,9 +30,35 @@ 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.
+- **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

@@ -75,15 +75,23 @@ 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)
         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
 
@@ -92,24 +100,24 @@ module PandaPal
 
           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 +127,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],
               })
@@ -148,20 +166,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 +223,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 +288,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 +317,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

data/app/models/panda_pal/session.rb

@@ -211,6 +211,20 @@ module PandaPal
       launch_params['https://www.instructure.com/placement'] || launch_params[:launch_type]
     end
 
+    # The PandaPal tool (see PandaPal.define_tool) this session was launched through.
+    def lti_tool
+      (tool.presence || PandaPal::DEFAULT_TOOL).to_sym
+    end
+
+    # The main_app route a +launch_type+ launch lands on, per this session's tool.
+    def lti_launch_route(launch_type)
+      LaunchUrlHelpers.launch_route(launch_type, tool: lti_tool)
+    end
+
+    def deep_link_redirect_url(request)
+      LaunchUrlHelpers.deep_link_redirect_url(request, tool: lti_tool)
+    end
+
     def custom_lti_params
       @custom_lti_params ||= begin
         # LT 1.3
@@ -230,7 +244,11 @@ module PandaPal
 
     def get_lti_cust_param(key, default: :if_not_var)
       nkey = key.to_s.gsub(/^custom_/, '')
-      default_value = ->() { PandaPal.lti_custom_params[nkey] || PandaPal.lti_custom_params["custom_#{nkey}"] }
+      default_value = ->() do
+        tool = PandaPal.lti_tool?(lti_tool) ? lti_tool : PandaPal::DEFAULT_TOOL
+        params = PandaPal.lti_custom_params(tool)
+        params[nkey] || params["custom_#{nkey}"]
+      end
 
       val = launch_params.dig("https://purl.imsglobal.org/spec/lti/claim/custom", nkey) || launch_params[nkey] || launch_params["custom_#{nkey}"]
 

data/config/initializers/apartment.rb

@@ -253,7 +253,7 @@ end
 
 Apartment.configure do |config|
   config.excluded_models ||= []
-  config.excluded_models |= ['PandaPal::Organization']
+  config.excluded_models |= ['PandaPal::Organization', 'PandaPal::LtiRegistration']
 
   config.with_multi_server_setup = true unless Rails.env.test?
 

data/db/migrate/20261006000000_create_panda_pal_lti_registrations.rb

@@ -0,0 +1,14 @@
+class CreatePandaPalLtiRegistrations < ActiveRecord::Migration[6.1]
+  def change
+    create_table :panda_pal_lti_registrations do |t|
+      t.references :panda_pal_organization, null: false, index: true
+      t.string :tool, null: false
+      t.string :client_id, null: false
+      t.string :deployment_id
+
+      t.timestamps null: false
+    end
+
+    add_index :panda_pal_lti_registrations, [:client_id, :deployment_id], unique: true, name: 'index_panda_pal_lti_registrations_on_client_and_deployment'
+  end
+end

data/db/migrate/20261006000001_add_tool_to_panda_pal_sessions.rb

@@ -0,0 +1,5 @@
+class AddToolToPandaPalSessions < ActiveRecord::Migration[6.1]
+  def change
+    add_column :panda_pal_sessions, :tool, :string
+  end
+end

data/lib/panda_pal/concerns/ability_helper.rb

@@ -45,7 +45,9 @@ module PandaPal::Concerns
         raise "Ability class needs to set @rails_session or @controller to use this feature"
       end
 
-      @rails_session ||= @controller.session unless defined?(@rails_session)
+      @rails_session ||= @controller&.session
+
+      @rails_session
     end
 
     # Delegate legacy AbilityHelper methods to panda_pal_session. TODO Should such direct usage be considered deprecated?