schwab_mcp 0.1.0

data/lib/schwab_mcp/tools/option_strategy_finder_tool.rb

@@ -0,0 +1,378 @@
+require "mcp"
+require "schwab_rb"
+require "json"
+require "date"
+require_relative "../loggable"
+require_relative "../option_chain_filter"
+
+module SchwabMCP
+  module Tools
+    class OptionStrategyFinderTool < MCP::Tool
+      extend Loggable
+      description "Find option strategies (iron condor, call spread, put spread) using Schwab API"
+
+      input_schema(
+        properties: {
+          strategy_type: {
+            type: "string",
+            description: "Type of option strategy to find",
+            enum: ["ironcondor", "callspread", "putspread"]
+          },
+          underlying_symbol: {
+            type: "string",
+            description: "Underlying symbol for the options (e.g., '$SPX', 'SPY')",
+            pattern: "^[A-Za-z$]{1,6}$"
+          },
+          expiration_date: {
+            type: "string",
+            description: "Target expiration date for options (YYYY-MM-DD format)"
+          },
+          expiration_type: {
+            type: "string",
+            description: "Type of expiration (e.g., 'W' for weekly, 'M' for monthly)",
+            enum: ["W", "M", "Q"]
+          },
+          settlement_type: {
+            type: "string",
+            description: "Settlement type (e.g., 'P' for PM settled, 'A' for AM settled)",
+            enum: ["P", "A"]
+          },
+          option_root: {
+            type: "string",
+            description: "Option root symbol (e.g., 'SPXW' for weekly SPX options)"
+          },
+          max_delta: {
+            type: "number",
+            description: "Maximum absolute delta for short legs (default: 0.15)",
+            minimum: 0.01,
+            maximum: 1.0
+          },
+          max_spread: {
+            type: "number",
+            description: "Maximum spread width in dollars (default: 20.0)",
+            minimum: 1.0
+          },
+          min_credit: {
+            type: "number",
+            description: "Minimum credit received in dollars (default: 100.0)",
+            minimum: 0.01
+          },
+          min_open_interest: {
+            type: "integer",
+            description: "Minimum open interest for options (default: 0)",
+            minimum: 0
+          },
+          dist_from_strike: {
+            type: "number",
+            description: "Minimum distance from current price as percentage (default: 0.07)",
+            minimum: 0.0,
+            maximum: 1.0
+          },
+          quantity: {
+            type: "integer",
+            description: "Number of contracts per leg (default: 1)",
+            minimum: 1
+          },
+          from_date: {
+            type: "string",
+            description: "Start date for expiration search (YYYY-MM-DD format)"
+          },
+          to_date: {
+            type: "string",
+            description: "End date for expiration search (YYYY-MM-DD format)"
+          }
+        },
+        required: ["strategy_type", "underlying_symbol", "expiration_date"]
+      )
+
+      annotations(
+        title: "Find Option Strategy",
+        read_only_hint: true,
+        destructive_hint: false,
+        idempotent_hint: true
+      )
+
+      def self.call(strategy_type:, underlying_symbol:, expiration_date:,
+                    expiration_type: nil, settlement_type: nil, option_root: nil,
+                    max_delta: 0.15, max_spread: 20.0, min_credit: 0.0,
+                    min_open_interest: 0, dist_from_strike: 0.0, quantity: 1,
+                    from_date: nil, to_date: nil, server_context:)
+
+        log_info("Finding #{strategy_type} strategy for #{underlying_symbol} expiring #{expiration_date}")
+
+        begin
+          unless %w[ironcondor callspread putspread].include?(strategy_type.downcase)
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Invalid strategy type '#{strategy_type}'. Must be one of: ironcondor, callspread, putspread"
+            }])
+          end
+
+          client = SchwabRb::Auth.init_client_easy(
+            ENV['SCHWAB_API_KEY'],
+            ENV['SCHWAB_APP_SECRET'],
+            ENV['SCHWAB_CALLBACK_URI'],
+            ENV['TOKEN_PATH']
+          )
+
+          unless client
+            log_error("Failed to initialize Schwab client")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
+            }])
+          end
+
+          exp_date = Date.parse(expiration_date)
+          from_dt = from_date ? Date.parse(from_date) : exp_date
+          to_dt = to_date ? Date.parse(to_date) : exp_date
+
+          contract_type = strategy_type.downcase == 'callspread' ? 'CALL' :
+                         strategy_type.downcase == 'putspread' ? 'PUT' : 'ALL'
+
+          log_debug("Fetching option chain for #{underlying_symbol} (#{contract_type})")
+
+          response = client.get_option_chain(
+            underlying_symbol.upcase,
+            contract_type: contract_type,
+            from_date: from_dt,
+            to_date: to_dt,
+            include_underlying_quote: true
+          )
+
+          unless response&.body
+            log_warn("Empty response from Schwab API for #{underlying_symbol}")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**No Data**: Could not retrieve option chain for #{underlying_symbol}"
+            }])
+          end
+
+          option_data = JSON.parse(response.body, symbolize_names: true)
+
+          result = find_strategy(
+            strategy_type: strategy_type.downcase,
+            option_data: option_data,
+            underlying_symbol: underlying_symbol,
+            expiration_date: exp_date,
+            expiration_type: expiration_type,
+            settlement_type: settlement_type,
+            option_root: option_root,
+            max_delta: max_delta,
+            max_spread: max_spread,
+            min_credit: min_credit,
+            min_open_interest: min_open_interest,
+            dist_from_strike: dist_from_strike,
+            quantity: quantity
+          )
+
+          if result.nil? || result[:status] == 'not_found'
+            log_info("No suitable #{strategy_type} found for #{underlying_symbol}")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**No Strategy Found**: Could not find a suitable #{strategy_type} for #{underlying_symbol} with the specified criteria."
+            }])
+          else
+            log_info("Found #{strategy_type} strategy for #{underlying_symbol}")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: format_strategy_result(result, strategy_type)
+            }])
+          end
+        rescue Date::Error => e
+          log_error("Invalid date format: #{e.message}")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Invalid date format. Use YYYY-MM-DD format."
+          }])
+        rescue JSON::ParserError => e
+          log_error("Failed to parse option chain data: #{e.message}")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Failed to parse option chain data from Schwab API."
+          }])
+        rescue => e
+          log_error("Error finding #{strategy_type} for #{underlying_symbol}: #{e.message}")
+          log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error** finding #{strategy_type} for #{underlying_symbol}: #{e.message}"
+          }])
+        end
+      end
+
+      private
+
+      def self.find_strategy(strategy_type:, option_data:, underlying_symbol:, expiration_date:,
+                            expiration_type:, settlement_type:, option_root:, max_delta:,
+                            max_spread:, min_credit:, min_open_interest:, dist_from_strike:, quantity:)
+
+        case strategy_type
+        when 'ironcondor'
+          find_iron_condor(option_data, underlying_symbol, expiration_date, expiration_type,
+                          settlement_type, option_root, max_delta, max_spread, min_credit / 2.0,
+                          min_open_interest, dist_from_strike, quantity)
+        when 'callspread'
+          find_spread(option_data, 'call', underlying_symbol, expiration_date, expiration_type,
+                     settlement_type, option_root, max_delta, max_spread, min_credit,
+                     min_open_interest, dist_from_strike, quantity)
+        when 'putspread'
+          find_spread(option_data, 'put', underlying_symbol, expiration_date, expiration_type,
+                     settlement_type, option_root, max_delta, max_spread, min_credit,
+                     min_open_interest, dist_from_strike, quantity)
+        end
+      end
+
+      def self.find_iron_condor(option_data, underlying_symbol, expiration_date, expiration_type,
+                               settlement_type, option_root, max_delta, max_spread, min_credit,
+                               min_open_interest, dist_from_strike, quantity)
+
+        underlying_price = option_data.dig(:underlyingPrice) || 0.0
+        call_options = option_data.dig(:callExpDateMap) || {}
+        put_options = option_data.dig(:putExpDateMap) || {}
+
+        filter = SchwabMCP::OptionChainFilter.new(
+          expiration_date: expiration_date,
+          underlying_price: underlying_price,
+          expiration_type: expiration_type,
+          settlement_type: settlement_type,
+          option_root: option_root,
+          max_delta: max_delta,
+          max_spread: max_spread,
+          min_credit: min_credit,
+          min_open_interest: min_open_interest,
+          dist_from_strike: dist_from_strike,
+          quantity: quantity
+        )
+
+        call_spreads = filter.find_spreads(call_options, 'call')
+        put_spreads = filter.find_spreads(put_options, 'put')
+
+        return { status: 'not_found' } if call_spreads.empty? || put_spreads.empty?
+
+        best_combo = nil
+        best_ratio = 0
+
+        call_spreads.each do |call_spread|
+          put_spreads.each do |put_spread|
+            total_credit = call_spread[:credit] + put_spread[:credit]
+            next if total_credit < min_credit / 100.0
+
+            total_delta = call_spread[:delta].abs + put_spread[:delta].abs
+            ratio = total_credit / total_delta if total_delta > 0
+
+            if ratio > best_ratio
+              best_ratio = ratio
+              best_combo = {
+                type: 'iron_condor',
+                call_spread: call_spread,
+                put_spread: put_spread,
+                total_credit: total_credit,
+                total_delta: total_delta,
+                underlying_price: underlying_price
+              }
+            end
+          end
+        end
+
+        best_combo || { status: 'not_found' }
+      end
+
+      def self.find_spread(option_data, spread_type, underlying_symbol, expiration_date, expiration_type,
+                          settlement_type, option_root, max_delta, max_spread, min_credit,
+                          min_open_interest, dist_from_strike, quantity)
+
+        underlying_price = option_data.dig(:underlyingPrice) || 0.0
+        options_map = case spread_type
+                     when 'call'
+                       option_data.dig(:callExpDateMap) || {}
+                     when 'put'
+                       option_data.dig(:putExpDateMap) || {}
+                     else
+                       return { status: 'not_found' }
+                     end
+
+        filter = SchwabMCP::OptionChainFilter.new(
+          expiration_date: expiration_date,
+          underlying_price: underlying_price,
+          expiration_type: expiration_type,
+          settlement_type: settlement_type,
+          option_root: option_root,
+          max_delta: max_delta,
+          max_spread: max_spread,
+          min_credit: min_credit,
+          min_open_interest: min_open_interest,
+          dist_from_strike: dist_from_strike,
+          quantity: quantity
+        )
+
+        spreads = filter.find_spreads(options_map, spread_type)
+
+        return { status: 'not_found' } if spreads.empty?
+
+        best_spread = spreads.max_by { |spread| spread[:credit] }
+        best_spread.merge(type: "#{spread_type}_spread", underlying_price: underlying_price)
+      end
+
+      def self.format_strategy_result(result, strategy_type)
+        case result[:type]
+        when 'iron_condor'
+          format_iron_condor(result)
+        when 'call_spread', 'put_spread'
+          format_spread(result, result[:type])
+        else
+          "**Found Strategy**: #{strategy_type.upcase}\n\n#{result.to_json}"
+        end
+      end
+
+      def self.format_iron_condor(result)
+        call_spread = result[:call_spread]
+        put_spread = result[:put_spread]
+
+        <<~TEXT
+          **IRON CONDOR FOUND**
+
+          **Underlying Price**: $#{result[:underlying_price].round(2)}
+          **Total Credit**: $#{(result[:total_credit] * 100).round(2)}
+
+          **Call Spread (Short)**:
+          - Short: #{call_spread[:short_option][:symbol]} $#{call_spread[:short_option][:strikePrice]} Call @ $#{call_spread[:short_option][:mark].round(2)}
+          - Long:  #{call_spread[:long_option][:symbol]} $#{call_spread[:long_option][:strikePrice]} Call @ $#{call_spread[:long_option][:mark].round(2)}
+          - Credit: $#{(call_spread[:credit] * 100).round(2)}
+          - Width: $#{call_spread[:spread_width].round(2)}
+          - Delta: #{call_spread[:delta].round(2)}
+
+          **Put Spread (Short)**:
+          - Short: #{put_spread[:short_option][:symbol]} $#{put_spread[:short_option][:strikePrice]} Put @ $#{put_spread[:short_option][:mark].round(2)}
+          - Long:  #{put_spread[:long_option][:symbol]} $#{put_spread[:long_option][:strikePrice]} Put @ $#{put_spread[:long_option][:mark].round(2)}
+          - Credit: $#{(put_spread[:credit] * 100).round(2)}
+          - Width: $#{put_spread[:spread_width].round(2)}
+          - Delta: #{put_spread[:delta].round(2)}
+        TEXT
+      end
+
+      def self.format_spread(result, spread_type)
+        short_opt = result[:short_option]
+        long_opt = result[:long_option]
+        option_type = spread_type == 'call_spread' ? 'Call' : 'Put'
+
+        <<~TEXT
+          **#{option_type.upcase} SPREAD FOUND**
+
+          **Underlying Price**: $#{result[:underlying_price].round(2)}
+          **Credit**: $#{(result[:credit] * 100).round(2)}
+          **Spread Width**: $#{result[:spread_width].round(2)}
+          **Delta**: #{result[:delta].round(4)}
+
+          **Short**: #{short_opt[:symbol]} $#{short_opt[:strikePrice]} #{option_type} @ $#{short_opt[:mark].round(2)}
+          - Delta: #{short_opt[:delta]&.round(4)}
+          - Open Interest: #{short_opt[:openInterest]}
+
+          **Long**: #{long_opt[:symbol]} $#{long_opt[:strikePrice]} #{option_type} @ $#{long_opt[:mark].round(2)}
+          - Delta: #{long_opt[:delta]&.round(4)}
+          - Open Interest: #{long_opt[:openInterest]}
+        TEXT
+      end
+    end
+  end
+end

data/lib/schwab_mcp/tools/place_order_tool.rb

@@ -0,0 +1,305 @@
+require "mcp"
+require "schwab_rb"
+require "json"
+require_relative "../loggable"
+require_relative "../orders/order_factory"
+require_relative "../redactor"
+
+module SchwabMCP
+  module Tools
+    class PlaceOrderTool < MCP::Tool
+      extend Loggable
+      description "Place an options order (iron condor, call spread, put spread) for execution on the Schwab platform"
+
+      input_schema(
+        properties: {
+          account_name: {
+            type: "string",
+            description: "Account name mapped to environment variable ending with '_ACCOUNT' (e.g., 'TRADING_BROKERAGE_ACCOUNT')",
+            pattern: "^[A-Z_]+_ACCOUNT$"
+          },
+          strategy_type: {
+            type: "string",
+            enum: ["ironcondor", "callspread", "putspread"],
+            description: "Type of options strategy to place"
+          },
+          price: {
+            type: "number",
+            description: "Net price for the order (credit for selling strategies, debit for buying strategies)"
+          },
+          quantity: {
+            type: "integer",
+            description: "Number of contracts (default: 1)",
+            default: 1
+          },
+          order_instruction: {
+            type: "string",
+            enum: ["open", "exit"],
+            description: "Whether to open a new position or exit an existing one (default: open)",
+            default: "open"
+          },
+          put_short_symbol: {
+            type: "string",
+            description: "Option symbol for the short put leg (required for iron condor)"
+          },
+          put_long_symbol: {
+            type: "string",
+            description: "Option symbol for the long put leg (required for iron condor)"
+          },
+          call_short_symbol: {
+            type: "string",
+            description: "Option symbol for the short call leg (required for iron condor)"
+          },
+          call_long_symbol: {
+            type: "string",
+            description: "Option symbol for the long call leg (required for iron condor)"
+          },
+          short_leg_symbol: {
+            type: "string",
+            description: "Option symbol for the short leg (required for call/put spreads)"
+          },
+          long_leg_symbol: {
+            type: "string",
+            description: "Option symbol for the long leg (required for call/put spreads)"
+          }
+        },
+        required: ["account_name", "strategy_type", "price"]
+      )
+
+      annotations(
+        title: "Place Options Order",
+        read_only_hint: false,
+        destructive_hint: true,
+        idempotent_hint: false
+      )
+
+      def self.call(server_context:, **params)
+        log_info("Placing #{params[:strategy_type]} order for account name: #{params[:account_name]}")
+
+        unless params[:account_name].end_with?('_ACCOUNT')
+          log_error("Invalid account name format: #{params[:account_name]}")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Account name must end with '_ACCOUNT'. Example: 'TRADING_BROKERAGE_ACCOUNT'"
+          }])
+        end
+
+        begin
+          validate_strategy_params(params)
+          client = SchwabRb::Auth.init_client_easy(
+            ENV['SCHWAB_API_KEY'],
+            ENV['SCHWAB_APP_SECRET'],
+            ENV['SCHWAB_CALLBACK_URI'],
+            ENV['TOKEN_PATH']
+          )
+
+          unless client
+            log_error("Failed to initialize Schwab client")
+            return MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
+            }])
+          end
+
+          account_result = resolve_account_details(client, params[:account_name])
+          return account_result if account_result.is_a?(MCP::Tool::Response)
+
+          account_id, account_hash = account_result
+
+          order_builder = SchwabMCP::Orders::OrderFactory.build(
+            strategy_type: params[:strategy_type],
+            account_number: account_id,
+            price: params[:price],
+            quantity: params[:quantity] || 1,
+            order_instruction: (params[:order_instruction] || "open").to_sym,
+            # Iron Condor params
+            put_short_symbol: params[:put_short_symbol],
+            put_long_symbol: params[:put_long_symbol],
+            call_short_symbol: params[:call_short_symbol],
+            call_long_symbol: params[:call_long_symbol],
+            # Vertical spread params
+            short_leg_symbol: params[:short_leg_symbol],
+            long_leg_symbol: params[:long_leg_symbol]
+          )
+
+          log_debug("Making place order API request")
+          response = client.place_order(account_hash, order_builder)
+
+          if response && (200..299).include?(response.status)
+            log_info("Successfully placed #{params[:strategy_type]} order (HTTP #{response.status})")
+            formatted_response = format_place_order_response(response, params)
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: formatted_response
+            }])
+          elsif response
+            log_error("Order placement failed with HTTP status #{response.status}")
+            error_details = extract_error_details(response)
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: "**Error**: Order placement failed (HTTP #{response.status})\n\n#{error_details}"
+            }])
+          else
+            log_warn("Empty response from Schwab API for order placement")
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: "**No Data**: Empty response from Schwab API for order placement"
+            }])
+          end
+
+        rescue => e
+          log_error("Error placing #{params[:strategy_type]} order: #{e.message}")
+          log_debug("Backtrace: #{e.backtrace.first(5).join('\n')}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error** placing #{params[:strategy_type]} order: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
+          }])
+        end
+      end
+
+      private
+
+      def self.resolve_account_details(client, account_name)
+        account_id = ENV[account_name]
+        unless account_id
+          available_accounts = ENV.keys.select { |key| key.end_with?('_ACCOUNT') }
+          log_error("Account name '#{account_name}' not found in environment variables")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Account name '#{account_name}' not found in environment variables.\n\nAvailable accounts: #{available_accounts.join(', ')}\n\nTo configure: Set ENV['#{account_name}'] to your account ID."
+          }])
+        end
+
+        log_debug("Found account ID: [REDACTED] for account name: #{account_name}")
+        log_debug("Fetching account numbers mapping")
+
+        account_numbers_response = client.get_account_numbers
+
+        unless account_numbers_response&.body
+          log_error("Failed to retrieve account numbers")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Failed to retrieve account numbers from Schwab API"
+          }])
+        end
+
+        account_mappings = JSON.parse(account_numbers_response.body, symbolize_names: true)
+        log_debug("Account mappings retrieved (#{account_mappings.length} accounts found)")
+
+        account_hash = nil
+        account_mappings.each do |mapping|
+          if mapping[:accountNumber] == account_id
+            account_hash = mapping[:hashValue]
+            break
+          end
+        end
+
+        unless account_hash
+          log_error("Account ID not found in available accounts")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Account ID not found in available accounts. #{account_mappings.length} accounts available."
+          }])
+        end
+
+        log_debug("Found account hash for account name: #{account_name}")
+        [account_id, account_hash]
+      end
+
+      def self.validate_strategy_params(params)
+        case params[:strategy_type]
+        when 'ironcondor'
+          required_fields = [:put_short_symbol, :put_long_symbol, :call_short_symbol, :call_long_symbol]
+          missing_fields = required_fields.select { |field| params[field].nil? || params[field].empty? }
+          unless missing_fields.empty?
+            raise ArgumentError, "Iron condor strategy requires: #{missing_fields.join(', ')}"
+          end
+        when 'callspread', 'putspread'
+          required_fields = [:short_leg_symbol, :long_leg_symbol]
+          missing_fields = required_fields.select { |field| params[field].nil? || params[field].empty? }
+          unless missing_fields.empty?
+            raise ArgumentError, "#{params[:strategy_type]} strategy requires: #{missing_fields.join(', ')}"
+          end
+        else
+          raise ArgumentError, "Unsupported strategy type: #{params[:strategy_type]}"
+        end
+      end
+
+      def self.format_place_order_response(response, params)
+        begin
+          strategy_summary = case params[:strategy_type]
+          when 'ironcondor'
+            "**Iron Condor Order Placed**\n" \
+            "- Put Short: #{params[:put_short_symbol]}\n" \
+            "- Put Long: #{params[:put_long_symbol]}\n" \
+            "- Call Short: #{params[:call_short_symbol]}\n" \
+            "- Call Long: #{params[:call_long_symbol]}\n"
+          when 'callspread', 'putspread'
+            "**#{params[:strategy_type].capitalize} Order Placed**\n" \
+            "- Short Leg: #{params[:short_leg_symbol]}\n" \
+            "- Long Leg: #{params[:long_leg_symbol]}\n"
+          end
+
+          friendly_name = params[:account_name].gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
+
+          order_details = "**Order Details:**\n" \
+                         "- Strategy: #{params[:strategy_type]}\n" \
+                         "- Action: #{params[:order_instruction] || 'open'}\n" \
+                         "- Quantity: #{params[:quantity] || 1}\n" \
+                         "- Price: $#{params[:price]}\n" \
+                         "- Account: #{friendly_name} (#{params[:account_name]})\n\n"
+
+          order_id = extract_order_id_from_response(response)
+          order_id_info = order_id ? "**Order ID**: #{order_id}\n\n" : ""
+
+          response_info = if response.body && !response.body.empty?
+            begin
+              parsed = JSON.parse(response.body)
+              redacted_data = Redactor.redact(parsed)
+              "**Schwab API Response:**\n\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
+            rescue JSON::ParserError
+              "**Schwab API Response:**\n\n```\n#{response.body}\n```"
+            end
+          else
+            "**Status**: Order submitted successfully (HTTP #{response.status})"
+          end
+
+          "#{strategy_summary}\n#{order_details}#{order_id_info}#{response_info}"
+        rescue => e
+          log_error("Error formatting response: #{e.message}")
+          "**Order Status**: #{response.status}\n\n**Raw Response**: #{response.body}"
+        end
+      end
+
+      def self.extract_order_id_from_response(response)
+        # Schwab API typically returns the order ID in the Location header
+        # Format: https://api.schwabapi.com/trader/v1/accounts/{accountHash}/orders/{orderId}
+        location = response.headers['Location'] || response.headers['location']
+        return nil unless location
+
+        match = location.match(%r{/orders/(\d+)$})
+        match ? match[1] : nil
+      rescue => e
+        log_debug("Could not extract order ID from response: #{e.message}")
+        nil
+      end
+
+      def self.extract_error_details(response)
+        if response.body && !response.body.empty?
+          begin
+            parsed = JSON.parse(response.body)
+            redacted_data = Redactor.redact(parsed)
+            "**Error Details:**\n\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
+          rescue JSON::ParserError
+            "**Error Details:**\n\n```\n#{response.body}\n```"
+          end
+        else
+          "No additional error details provided."
+        end
+      rescue => e
+        log_debug("Error extracting error details: #{e.message}")
+        "Could not extract error details."
+      end
+    end
+  end
+end