DhanHQ 3.2.0 → 3.3.0

data/lib/DhanHQ/concerns/bang_writes.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../write_result"
+
+module DhanHQ
+  module Concerns
+    # Generates bang variants of write methods that raise instead of returning a falsy
+    # value or an {DhanHQ::ErrorObject}.
+    #
+    # Each generated method calls its non-bang counterpart and passes the result through
+    # {DhanHQ::WriteResult.unwrap!}, so the two cannot drift: there is no duplicated
+    # request building, validation or logging. The non-bang methods are untouched, which
+    # is what makes this additive — existing callers keep the return values they were
+    # written against.
+    #
+    # @example
+    #   class Order < BaseModel
+    #     extend DhanHQ::Concerns::BangWrites
+    #
+    #     bang_class_writes :place        # defines Order.place!
+    #     bang_writes :modify, :cancel    # defines #modify! and #cancel!
+    #   end
+    #
+    #   Order.place!(params)   # => Order, or raises DhanHQ::OrderError
+    #   order.cancel!          # => true,  or raises DhanHQ::OrderError
+    module BangWrites
+      # Defines `<name>!` instance methods.
+      #
+      # @param names [Array<Symbol>] Existing instance write methods to wrap.
+      # @param error_class [Class] Exception the generated methods raise.
+      # @return [void]
+      def bang_writes(*names, error_class: DhanHQ::OrderError)
+        names.each { |name| include bang_write_module(name, error_class) }
+      end
+
+      # Defines `<name>!` class methods.
+      #
+      # @param names [Array<Symbol>] Existing class write methods to wrap.
+      # @param error_class [Class] Exception the generated methods raise.
+      # @return [void]
+      def bang_class_writes(*names, error_class: DhanHQ::OrderError)
+        names.each { |name| singleton_class.include bang_write_module(name, error_class) }
+      end
+
+      private
+
+      # Built as a module rather than defined directly, so a hand-written `place!` in
+      # the class body still overrides the generated one and can call `super`.
+      def bang_write_module(name, error_class)
+        Module.new do
+          define_method(:"#{name}!") do |*args, **kwargs, &block|
+            # A caller already using the bang variant does not need a deprecation
+            # notice telling them to use the bang variant.
+            result = DhanHQ::WriteResult.suppressing_deprecation do
+              public_send(name, *args, **kwargs, &block)
+            end
+
+            DhanHQ::WriteResult.unwrap!(
+              result,
+              operation: DhanHQ::WriteResult.operation_label(self, name),
+              error_class: error_class,
+              errors: DhanHQ::WriteResult.errors_from(self)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/concerns/tracked_writes.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../write_result"
+
+module DhanHQ
+  module Concerns
+    # Observes non-bang write methods and reports, once per call site, when one returns
+    # a failure shape that 4.0.0 will change.
+    #
+    # Uses +prepend+ rather than +include+ because these methods are defined directly on
+    # the model classes: an included module sits behind the class in the ancestor chain
+    # and would never be reached. A prepended one sits in front, so +super+ runs the real
+    # method and the result passes through untouched.
+    #
+    # This layer only observes. It never changes a return value, never raises, and goes
+    # quiet once a call site has been migrated to the bang variant.
+    #
+    # @example
+    #   class Order < BaseModel
+    #     extend DhanHQ::Concerns::TrackedWrites
+    #
+    #     track_class_writes :place        # warns when Order.place returns nil
+    #     track_writes :modify, :cancel    # warns when #cancel returns false
+    #   end
+    module TrackedWrites
+      # Observes `<name>` instance methods.
+      #
+      # @param names [Array<Symbol>] Existing instance write methods to observe.
+      # @return [void]
+      def track_writes(*names)
+        names.each { |name| prepend tracking_module(name) }
+      end
+
+      # Observes `<name>` class methods.
+      #
+      # @param names [Array<Symbol>] Existing class write methods to observe.
+      # @return [void]
+      def track_class_writes(*names)
+        names.each { |name| singleton_class.prepend tracking_module(name) }
+      end
+
+      private
+
+      def tracking_module(name)
+        Module.new do
+          define_method(name) do |*args, **kwargs, &block|
+            DhanHQ::WriteResult.report_ambiguous_failure(
+              super(*args, **kwargs, &block),
+              operation: DhanHQ::WriteResult.operation_label(self, name)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/configuration.rb

@@ -60,7 +60,7 @@ module DhanHQ
     # /v2/orders that times out may well have reached the exchange, and retrying it
     # can place a second, duplicate order. With this off, the transient error is
     # raised to the caller, who can reconcile using the correlation id (see
-    # {#auto_correlation_id} and +DhanHQ::Models::Order.find_by_correlation_id+)
+    # {#auto_correlation_id} and +DhanHQ::Models::Order.find_by_correlation+)
     # before deciding to resubmit.
     #
     # Read requests are always retried regardless of this setting.
@@ -69,6 +69,19 @@ module DhanHQ
     # @return [Boolean]
     attr_accessor :retry_non_idempotent_writes
 
+    # Whether to log a deprecation notice, once per call site, when a non-bang write
+    # method reports failure through +nil+, +false+ or a {DhanHQ::ErrorObject}.
+    #
+    # Those contracts disagree today and will unify on {DhanHQ::ErrorObject} in 4.0.0,
+    # which is truthy — so an `if result` failure branch written against +nil+ or
+    # +false+ will silently invert. The notice names the call sites that need moving to
+    # a bang variant before then.
+    #
+    # Defaults to +true+: a notice nobody sees finds nothing. Set to +false+ once the
+    # call sites are migrated, or via +DHAN_WARN_AMBIGUOUS_WRITE_FAILURE=false+.
+    # @return [Boolean]
+    attr_accessor :warn_on_ambiguous_write_failure
+
     # Whether to generate a +correlationId+ for order placements that do not carry
     # one. The correlation id is the only way to answer "did my order actually go
     # through?" after a timeout, via GET /v2/orders/external/{correlation-id}.
@@ -175,6 +188,11 @@ module DhanHQ
       @retry_non_idempotent_writes == true
     end
 
+    # @return [Boolean] True when ambiguous write failures should be reported.
+    def warn_on_ambiguous_write_failure?
+      @warn_on_ambiguous_write_failure == true
+    end
+
     # @return [Boolean] True when a correlation id should be generated for orders.
     def auto_correlation_id?
       @auto_correlation_id == true
@@ -193,6 +211,7 @@ module DhanHQ
       @dry_run        = env_flag("DHAN_DRY_RUN", default: false)
       @retry_non_idempotent_writes = env_flag("DHAN_RETRY_WRITES", default: false)
       @auto_correlation_id = env_flag("DHAN_AUTO_CORRELATION_ID", default: false)
+      @warn_on_ambiguous_write_failure = env_flag("DHAN_WARN_AMBIGUOUS_WRITE_FAILURE", default: true)
       @base_url       = ENV.fetch("DHAN_BASE_URL", nil)
       @ws_version     = ENV.fetch("DHAN_WS_VERSION", 2).to_i
       @ws_order_url = ENV.fetch("DHAN_WS_ORDER_URL", nil)

data/lib/DhanHQ/core/base_model.rb

@@ -193,19 +193,12 @@ module DhanHQ
     # @return [DhanHQ::BaseModel]
     # @raise [DhanHQ::Error] When the record cannot be saved.
     def save!
-      result = save
-      return result unless result == false || result.nil? || result.is_a?(DhanHQ::ErrorObject)
-
-      error_details =
-        if result.is_a?(DhanHQ::ErrorObject)
-          result.errors
-        elsif @errors && !@errors.empty?
-          @errors
-        else
-          "Unknown error"
-        end
-
-      raise DhanHQ::Error, "Failed to save the record: #{error_details}"
+      DhanHQ::WriteResult.unwrap!(
+        save,
+        operation: "#{self.class}#save",
+        error_class: DhanHQ::Error,
+        errors: @errors
+      )
     end
 
     # Delete the resource

data/lib/DhanHQ/deprecation.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Emits a deprecation notice once per call site per process.
+  #
+  # A trading process can reject hundreds of orders in a session. A notice that fires
+  # on every one of them is noise that gets filtered out, which defeats the purpose —
+  # the point is for a maintainer to find the handful of call sites still relying on
+  # behaviour that is going to change, then fix them.
+  module Deprecation
+    @warned = {}
+    @mutex = Mutex.new
+
+    class << self
+      # Logs +message+ the first time this +key+ is seen in this process.
+      #
+      # A command, not a query: callers that need to know whether a notice was emitted
+      # should consult {.warned_keys}.
+      #
+      # @param key [String, Symbol] Identifies the call site, e.g. the operation name.
+      # @param message [String] What is deprecated and what to do instead.
+      # @return [void]
+      def warn_once(key, message)
+        return unless first_warning_for?(key)
+
+        DhanHQ.logger&.warn("[DhanHQ] DEPRECATION: #{message}")
+        nil
+      end
+
+      # Keys already warned about, for assertions and diagnostics.
+      #
+      # @return [Array<String>]
+      def warned_keys
+        @mutex.synchronize { @warned.keys }
+      end
+
+      # Forgets every emitted notice, so the next occurrence warns again.
+      # Intended for test isolation.
+      #
+      # @return [void]
+      def reset!
+        @mutex.synchronize { @warned.clear }
+      end
+
+      private
+
+      # Whether this is the first time +key+ has been seen, recording it either way.
+      #
+      # The check and the record happen under one lock so two threads hitting the same
+      # call site at once cannot both decide they are first.
+      #
+      # @return [Boolean]
+      def first_warning_for?(key)
+        @mutex.synchronize do
+          next false if @warned.key?(key.to_s)
+
+          @warned[key.to_s] = true
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/models/alert_order.rb

@@ -6,6 +6,13 @@ module DhanHQ
   module Models
     # Model for alert/conditional orders. CRUD via AlertOrders resource; validated by AlertOrderContract.
     class AlertOrder < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :create, :modify
+
+      bang_class_writes :create, :modify
+
       include Concerns::ApiResponseHandler
 
       HTTP_PATH = "/v2/alerts/orders"
@@ -96,7 +103,7 @@ module DhanHQ
         handle_api_response(response, success_key: new_record? ? "alertId" : nil)
       end
 
-      def destroy # rubocop:disable Naming/PredicateMethod
+      def destroy
         return false if new_record?
 
         response = self.class.resource.delete(id)

data/lib/DhanHQ/models/forever_order.rb

@@ -66,6 +66,15 @@ module DhanHQ
     #   orders.each { |order| puts order.order_status }
     #
     class ForeverOrder < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :create
+      track_writes :modify, :cancel
+
+      bang_class_writes :create
+      bang_writes :modify, :cancel
+
       include Concerns::ApiResponseHandler
 
       attributes :dhan_client_id, :order_id, :correlation_id, :order_status,

data/lib/DhanHQ/models/global_stocks/order.rb

@@ -36,6 +36,15 @@ module DhanHQ
       #   end
       #
       class Order < BaseModel
+        extend DhanHQ::Concerns::BangWrites
+        extend DhanHQ::Concerns::TrackedWrites
+
+        track_class_writes :place
+        track_writes :modify, :cancel
+
+        bang_class_writes :place
+        bang_writes :modify, :cancel
+
         HTTP_PATH = "/v2/globalstocks/orders"
 
         attributes :dhan_client_id, :order_id, :exchange_order_id, :correlation_id,

data/lib/DhanHQ/models/iceberg_order.rb

@@ -48,6 +48,15 @@ module DhanHQ
     #   orders = DhanHQ::Models::IcebergOrder.all
     #
     class IcebergOrder < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :create
+      track_writes :modify, :cancel
+
+      bang_class_writes :create
+      bang_writes :modify, :cancel
+
       include Concerns::ApiResponseHandler
 
       attributes :dhan_client_id, :order_id, :correlation_id, :order_status,

data/lib/DhanHQ/models/multi_order.rb

@@ -26,6 +26,13 @@ module DhanHQ
     #   result.for_sequence("1").order_id
     #
     class MultiOrder < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :place
+
+      bang_class_writes :place
+
       HTTP_PATH = "/v2/alerts/multi/orders"
 
       attributes :orders

data/lib/DhanHQ/models/order.rb

@@ -46,6 +46,15 @@ module DhanHQ
     #   puts "Pending orders: #{pending_orders.count}"
     #
     class Order < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :place, :create
+      track_writes :modify, :cancel
+
+      bang_class_writes :place, :create
+      bang_writes :modify, :cancel, :refresh
+
       include Concerns::ApiResponseHandler
 
       # Attributes eligible for modification requests.
@@ -430,6 +439,25 @@ module DhanHQ
           order.save # calls resource create or update
           order
         end
+
+        # `create` always returns the built `Order`, even when `#save` returned
+        # `false` -- existing callers rely on that to inspect an unsaved order's
+        # `errors`, so `create` cannot change. The generated `create!` would
+        # therefore call `unwrap!` on an object that is truthy regardless of
+        # whether the placement actually succeeded, and never raise. This
+        # hand-written override supersedes it (see {BangWrites} for why a
+        # class-body definition takes precedence) and unwraps on `persisted?`
+        # instead, which reflects whether the API actually accepted the order.
+        def create!(params)
+          order = DhanHQ::WriteResult.suppressing_deprecation { create(params) }
+
+          DhanHQ::WriteResult.unwrap!(
+            order.persisted? ? order : false,
+            operation: DhanHQ::WriteResult.operation_label(self, :create),
+            error_class: DhanHQ::OrderError,
+            errors: DhanHQ::WriteResult.errors_from(order)
+          )
+        end
       end
 
       ##

data/lib/DhanHQ/models/pnl_exit.rb

@@ -32,6 +32,13 @@ module DhanHQ
     #   puts response[:pnl_exit_status] # => "DISABLED"
     #
     class PnlExit < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :configure, :stop
+
+      bang_class_writes :configure, :stop
+
       HTTP_PATH = "/v2/pnlExit"
 
       attributes :pnl_exit_status, :profit, :loss, :segments, :enable_kill_switch

data/lib/DhanHQ/models/super_order.rb

@@ -48,6 +48,15 @@ module DhanHQ
     #   order.cancel("STOP_LOSS_LEG")
     #
     class SuperOrder < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :create
+      track_writes :modify, :cancel
+
+      bang_class_writes :create
+      bang_writes :modify, :cancel
+
       include Concerns::ApiResponseHandler
 
       attributes :dhan_client_id, :order_id, :correlation_id, :order_status,

data/lib/DhanHQ/models/twap_order.rb

@@ -45,6 +45,15 @@ module DhanHQ
     #   order.cancel
     #
     class TwapOrder < BaseModel
+      extend DhanHQ::Concerns::BangWrites
+      extend DhanHQ::Concerns::TrackedWrites
+
+      track_class_writes :create
+      track_writes :modify, :cancel
+
+      bang_class_writes :create
+      bang_writes :modify, :cancel
+
       include Concerns::ApiResponseHandler
 
       attributes :dhan_client_id, :order_id, :correlation_id, :order_status,

data/lib/DhanHQ/risk/pipeline.rb

@@ -51,14 +51,12 @@ module DhanHQ
       # @param type [Symbol] :equity or :options
       # @return [true] if all checks pass
       # @raise [DhanHQ::RiskViolation] on first failure
-      # rubocop:disable Naming/PredicateMethod
       def self.run!(instrument:, args:, now: Time.now, type: :equity)
         run_checks!(CHECKS, instrument, args, now)
         run_checks!(OPTION_CHECKS, instrument, args, now) if type == :options
         run_checks!(DAILY_CHECKS, instrument, args, now)
         true
       end
-      # rubocop:enable Naming/PredicateMethod
 
       def self.run_checks!(checks, instrument, args, now)
         checks.each do |check|

data/lib/DhanHQ/version.rb

@@ -2,5 +2,5 @@
 
 module DhanHQ
   # Semantic version of the DhanHQ client gem.
-  VERSION = "3.2.0"
+  VERSION = "3.3.0"
 end

data/lib/DhanHQ/write_result.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Interprets the several shapes a write currently uses to signal failure.
+  #
+  # The model write methods do not share a return contract. Depending on which class
+  # and which failure you hit, a rejected write comes back as +nil+, as +false+, or as
+  # a {DhanHQ::ErrorObject} — and {DhanHQ::Models::AlertOrder.modify} can return either
+  # of the first two from the same method. A caller cannot write one error branch.
+  #
+  # Unifying those contracts is a breaking change for the applications that depend on
+  # this gem, so it is staged (see CHANGELOG). This module is step one: it puts the
+  # knowledge of "what does failure look like" in exactly one place, and backs the bang
+  # variants (+place!+, +modify!+, +cancel!+, …) that give callers a single, explicit
+  # failure mode to rescue today.
+  #
+  # @example Opting a call site into explicit failures
+  #   order = DhanHQ::Models::Order.place!(params)   # raises DhanHQ::OrderError
+  #   # instead of
+  #   order = DhanHQ::Models::Order.place(params)    # nil on failure
+  module WriteResult
+    # Thread-local flag set while a bang variant is calling through.
+    SUPPRESSION_KEY = :dhanhq_suppress_write_deprecation
+
+    module_function
+
+    # Whether a write result represents a rejected or failed operation.
+    #
+    # @param result [Object] Return value of a write method.
+    # @return [Boolean]
+    def failure?(result)
+      result.nil? || result == false || result.is_a?(DhanHQ::ErrorObject)
+    end
+
+    # @param result [Object] Return value of a write method.
+    # @return [Boolean]
+    def success?(result)
+      !failure?(result)
+    end
+
+    # Returns the result, or raises carrying whatever diagnostics the failure held.
+    #
+    # @param result [Object] Return value of a write method.
+    # @param operation [String] Human-readable operation name for the message,
+    #   e.g. +"DhanHQ::Models::Order.place"+.
+    # @param error_class [Class] Exception to raise. Defaults to {DhanHQ::OrderError},
+    #   which descends from {DhanHQ::Error}, so existing `rescue DhanHQ::Error`
+    #   handlers still catch it.
+    # @param errors [Hash, nil] Validation errors to report when the result itself
+    #   carries none — typically a model's +errors+ hash.
+    # @return [Object] The result, when it represents success.
+    # @raise [DhanHQ::Error] When the result represents failure.
+    def unwrap!(result, operation:, error_class: DhanHQ::OrderError, errors: nil)
+      return result if success?(result)
+
+      raise error_class, "#{operation} failed: #{describe(result, errors)}"
+    end
+
+    # Reports, once per call site, that a non-bang write signalled failure through a
+    # value whose shape is going to change in 4.0.0.
+    #
+    # Step two of the migration: the notice tells a maintainer which of their call
+    # sites still branch on the old return value, so they can move to the bang variant
+    # before the non-bang contract unifies on {DhanHQ::ErrorObject}. Returns the result
+    # untouched — this observes, it never alters behaviour.
+    #
+    # Silent when the write succeeded, when the caller opted out via
+    # +config.warn_on_ambiguous_write_failure = false+, or when reached through a bang
+    # variant (those callers have already migrated — see {.suppressing_deprecation}).
+    #
+    # @param result [Object] Return value of a non-bang write method.
+    # @param operation [String] Operation label from {.operation_label}.
+    # @return [Object] The result, unchanged.
+    def report_ambiguous_failure(result, operation:)
+      return result unless failure?(result)
+      return result if suppressed?
+      return result unless DhanHQ.configuration&.warn_on_ambiguous_write_failure?
+
+      DhanHQ::Deprecation.warn_once(
+        operation,
+        "#{operation} reported failure as #{shape_of(result)}. Write methods return " \
+        "nil, false or a DhanHQ::ErrorObject inconsistently today and will all return " \
+        "DhanHQ::ErrorObject in 4.0.0, which is truthy — an `if result` failure branch " \
+        "will invert. Use #{operation}! to get a DhanHQ::OrderError instead, or set " \
+        "config.warn_on_ambiguous_write_failure = false to silence this."
+      )
+
+      result
+    end
+
+    # Runs the block with {.report_ambiguous_failure} disabled on this thread.
+    #
+    # Used by the bang variants: they call the non-bang method to get its result, and a
+    # caller who has already moved to `place!` does not need telling to move to
+    # `place!`. Thread-local so a concurrent thread still gets its own notices.
+    #
+    # @return [Object] The block's value.
+    def suppressing_deprecation
+      previous = Thread.current[SUPPRESSION_KEY]
+      Thread.current[SUPPRESSION_KEY] = true
+      yield
+    ensure
+      Thread.current[SUPPRESSION_KEY] = previous
+    end
+
+    # @return [Boolean]
+    def suppressed?
+      Thread.current[SUPPRESSION_KEY] == true
+    end
+
+    # Names the shape a failure arrived in, for the notice.
+    #
+    # @return [String]
+    def shape_of(result)
+      return "nil" if result.nil?
+      return "false" if result == false
+
+      "a DhanHQ::ErrorObject"
+    end
+
+    # Label identifying the operation that failed, for the exception message.
+    #
+    # @param receiver [Object] The class (for a class method) or instance.
+    # @param name [Symbol] Method name.
+    # @return [String] e.g. +"DhanHQ::Models::Order.place"+ or +"…Order#modify"+.
+    def operation_label(receiver, name)
+      return "#{module_label(receiver)}.#{name}" if receiver.is_a?(Module)
+
+      "#{module_label(receiver.class)}##{name}"
+    end
+
+    # Reads a module's declared name, falling back to +to_s+ so an anonymous class
+    # still yields something readable rather than an object address.
+    #
+    # @return [String]
+    def module_label(mod)
+      mod.name || mod.to_s
+    end
+
+    # Validation errors carried by a model instance, when it has any.
+    #
+    # @param receiver [Object]
+    # @return [Hash, nil]
+    def errors_from(receiver)
+      return nil if receiver.is_a?(Module)
+      return nil unless receiver.respond_to?(:errors)
+
+      receiver.errors
+    end
+
+    # Best available explanation for a failure.
+    #
+    # @return [String]
+    def describe(result, errors = nil)
+      return result.errors.to_s if result.is_a?(DhanHQ::ErrorObject)
+      return errors.to_s if errors && !errors.empty?
+
+      # `nil` and `false` carry nothing, so say which of the two it was rather than
+      # inventing a cause.
+      result.nil? ? "the API returned no record" : "the API rejected the request"
+    end
+  end
+end

data/lib/dhan_hq.rb

@@ -26,11 +26,20 @@ module DhanHQ
   LOADER = Zeitwerk::Loader.new
   LOADER.tag = "dhanhq"
   LOADER.inflector.inflect(
+    # Without this, Zeitwerk looks for DhanHQ::Ai while ai.rb defines DhanHQ::AI, so
+    # DhanHQ::AI::PromptHelpers raised NameError unless something had already loaded
+    # the file by hand — which only mcp/server.rb did.
+    "ai" => "AI",
     "api_helper" => "APIHelper",
     "auth_api" => "AuthAPI",
     "base_api" => "BaseAPI",
     "ip_setup" => "IPSetup",
     "json_loader" => "JSONLoader",
+    # Same failure as "ai" above: mcp.rb defines DhanHQ::MCP while Zeitwerk expected
+    # DhanHQ::Mcp, so DhanHQ::MCP::Server raised NameError after a bare `require
+    # "dhan_hq"` — it only worked via exe/dhanhq-mcp and lib/dhan_hq/mcp.rb, which
+    # require_relative the file directly instead of going through the autoloader.
+    "mcp" => "MCP",
     "ws" => "WS"
   )
   LOADER.push_dir(File.join(__dir__, "DhanHQ"), namespace: self)